JAVA认证考试专业语言基础知识28

会计考友 · 发表于 2012-8-4 12:44:44

首先我们先看看Bruce Eckel是怎么说的：

In the JVM an increment is not atomic and involves both a read and a write. （via the latest Java Performance Tuning Newsletter）

意思很简单，就是说在jvm中自增不是原子性操作，它包含一个读操作和一个写操作。

2、以上可能还不能让你信服，要想让人心服口服，就必须用代码说话。正如FaceBook的文化一样：代码赢得争论。那我们就看一段代码：

以下的代码是用100个线程同时执行自增操作，每个线程自增100次，如果自增操作是原子性操作的话，那么执行完amount的值为10,000.运行代码之后，你会发现amount的值小于10,000,这就说明自增操作不是原子性的

1./**

2. *

3. * @author renrun.wu

4. */

5.public class MultiThread implements Runnable {

6. private int count;

7. private int amount = 1;

8.

9. public MultiThread（） {

10. count = 100;

11. }

12.

13. public MultiThread（int count） {

14. this.count = count;

15. }

16.

会计考友 · 发表于 2012-8-4 12:44:45

17. @Override

18. public void run（） {

19.       for （int i = 0; i < count; i++） {

20.          amount++;

21.       }

22. }

23.

24. public static void main（String[] args） {

25.       ExecutorService executorService = Executors.newCachedThreadPool（）；

26.       MultiThread multiThread =new MultiThread（）；

27.       for （int i = 0; i < 100; i++） {

28.          executorService.execute（multiThread）；

29.       }

30.       executorService.shutdown（）；

31.

32.       try {

33.          Thread.sleep（60000）；

34.       } catch （InterruptedException e） {

35.          e.printStackTrace（）；

36.       }

37.       System.out.println（multiThread.amount）；

38. }

39.}

3、如果以上还不能让你信服的话，也没关系。我们就把自增操作反编译出来，看看java字节码是怎么操作的

以下是一个简单的自增操作代码

1.public class Increment {

2. private int id = 0;

3.4. public void getNext（）{

5.       id++;

6. }

会计考友 · 发表于 2012-8-4 12:44:46

7.}

我们看看反编译之后的Java字节码，主要关注getNext（）方法内部的Java字节码。

1.public class Increment extends java.lang.Object{

2. public Increment（）；

3.    Code:

4.: aload_0

5.: invokespecial #1; //Method java/lang/Object."":（）V

6.: aload_0

7.: iconst_0

8.: putfield       #2; //Field id:I

9.: return

10.

11. public void getNext（）；

12.    Code:

13.: aload_0 //加载局部变量表index为0的变量，在这里是this

14.: dup                //将当前栈顶的对象引用复制一份

15.: getfield       #2; //Field id:I,获取id的值，并将其值压入栈顶

16.: iconst_1          //将int型的值1压入栈顶

17.: iadd             //将栈顶两个int类型的元素相加，并将其值压入栈顶

18.: putfield       #2; //Field id:I,将栈顶的值赋值给id

19.:  return

20.

21. }

会计考友 · 发表于 2012-8-4 12:44:47

很明显，我们能够看到在getNext（）方法内部，对于类变量id有一个先取值后加一再赋值的过程。因此，我们可以很肯定的说Java中的自增操作不是原子性的。

4、也许你会问，那局部变量的自增操作是否是原子性的。好，我们在看看一下代码：

1.public class Increment {

2. public void getNext（）{

3. int id = 0;

4.       id++;

5. }

6.}

我们再看看反编译之后的Java字节码，主要还是关注getNext（）方法内部的Java字节码。

1.public class Increment extends java.lang.Object{

2.public Increment（）；

3.  Code:

4.: aload_0

5.: invokespecial #1; //Method java/lang/Object."":（）V

6.: return

7.

8.public void getNext（）；

9.  Code:

10.: iconst_0

11.: istore_1

12.: iinc 1, 1

13.: return

14.

15.}

与全局变量的自增操作相比，很明显局部变量的自增操作少了getfield与putfield操作。而且对于局部变量来说，它无论如何都不会涉及到多线程的操作，因此局部变量的自增操作是否是原子操作也就显得不那么重要了。

		自动登录	找回密码
密码			立即注册

[专业语言] JAVA认证考试专业语言基础知识28