日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
關于Java自增操作的原子性

最近在工作中和一個同事因為自增是不是原子性操作爭論的面紅耳赤，那Java的自增操作到底是不是原子性操作呢，答案是否的，即Java的自增操作不是原子性操作。

站在用戶的角度思考問題，與客戶深入溝通，找到邗江網(wǎng)站設計與邗江網(wǎng)站推廣的解決方案，憑借多年的經(jīng)驗，讓設計與互聯(lián)網(wǎng)技術結(jié)合，創(chuàng)造個性化、用戶體驗好的作品，建站類型包括：做網(wǎng)站、成都做網(wǎng)站、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣、域名申請、雅安服務器托管、企業(yè)郵箱。業(yè)務覆蓋邗江地區(qū)。

1.首先我們先看看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個線程同時執(zhí)行自增操作，每個線程自增100次，如果自增操作是原子性操作的話，那么執(zhí)行完amount的值為10,000。運行代碼之后，你會發(fā)現(xiàn)amount的值小于10,000，這就說明自增操作不是原子性的

 
 
 
    
  
  
  
  1. /**  
    2. 
  
  
  
  2.  *   
    3. 
  
  
  
  3.  * @author renrun.wu  
    4. 
  
  
  
  4.  */ 
    5. 
  
  
  
  5. public class MultiThread implements Runnable {  
    6. 
  
  
  
  6.     private int count;  
    7. 
  
  
  
  7.     private int amount = 1;  
    8. 
  
  
  
  8.       
    9. 
  
  
  
  9.     public MultiThread() {  
    10. 
  
  
  
  10.          count = 100;  
    11. 
  
  
  
  11.     }  
    12. 
  
  
  
  12.       
    13. 
  
  
  
  13.     public MultiThread(int count) {  
    14. 
  
  
  
  14.         this.count = count;  
    15. 
  
  
  
  15.     }  
    16. 
  
  
  
  16.       
    17. 
  
  
  
  17.     @Override 
    18. 
  
  
  
  18.     public void run() {  
    19. 
  
  
  
  19.         for (int i = 0; i < count; i++) {  
    20. 
  
  
  
  20.             amount++;  
    21. 
  
  
  
  21.         }  
    22. 
  
  
  
  22.     }  
    23. 
  
  
  
  23.       
    24. 
  
  
  
  24.     public static void main(String[] args) {  
    25. 
  
  
  
  25.         ExecutorService executorService = Executors.newCachedThreadPool();  
    26. 
  
  
  
  26.         MultiThread multiThread =new MultiThread();  
    27. 
  
  
  
  27.         for (int i = 0; i < 100; i++) {  
    28. 
  
  
  
  28.             executorService.execute(multiThread);  
    29. 
  
  
  
  29.         }  
    30. 
  
  
  
  30.         executorService.shutdown();  
    31. 
  
  
  
  31.           
    32. 
  
  
  
  32.         try {  
    33. 
  
  
  
  33.             Thread.sleep(60000);  
    34. 
  
  
  
  34.         } catch (InterruptedException e) {  
    35. 
  
  
  
  35.             e.printStackTrace();  
    36. 
  
  
  
  36.         }  
    37. 
  
  
  
  37.         System.out.println(multiThread.amount);  
    38. 
  
  
  
  38.     }  
    39. 
  
  
  
  39. } 
    40.

3.如果以上還不能讓你信服的話，也沒關系。我們就把自增操作反編譯出來，看看java字節(jié)碼是怎么操作的

以下是一個簡單的自增操作代碼

 
 
 
    
  
  
  
  1. public class Increment {  
    2. 
  
  
  
  2.     private int id = 0;  
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     public void getNext(){  
    5. 
  
  
  
  5.         id++;  
    6. 
  
  
  
  6.     }  
    7. 
  
  
  
  7. } 
    8.

我們看看反編譯之后的Java字節(jié)碼，主要關注getNext()方法內(nèi)部的Java字節(jié)碼。

 
 
 
    
  
  
  
  1. public class Increment extends java.lang.Object{  
    2. 
  
  
  
  2.     public Increment();  
    3. 
  
  
  
  3.       Code:  
    4. 
  
  
  
  4. :   aload_0  
    5. 
  
  
  
  5. :   invokespecial   #1; //Method java/lang/Object."":()V  
    6. 
  
  
  
  6. :   aload_0  
    7. 
  
  
  
  7. :   iconst_0  
    8. 
  
  
  
  8. :   putfield        #2; //Field id:I  
    9. 
  
  
  
  9. :   return 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.     public void getNext();  
    12. 
  
  
  
  12.       Code:  
    13. 
  
  
  
  13. :   aload_0　　　　　　   //加載局部變量表index為0的變量，在這里是this   
    14. 
  
  
  
  14. :   dup                 //將當前棧頂?shù)膶ο笠脧椭埔环? 
    15. 
  
  
  
  15. :   getfield        #2; //Field id:I,獲取id的值,并將其值壓入棧頂  
    16. 
  
  
  
  16. :   iconst_1            //將int型的值1壓入棧頂  
    17. 
  
  
  
  17. :   iadd                //將棧頂兩個int類型的元素相加，并將其值壓入棧頂  
    18. 
  
  
  
  18. :   putfield        #2; //Field id:I,將棧頂?shù)闹蒂x值給id  
    19. 
  
  
  
  19. :  return 
    20. 
  
  
  
  20.  
    21. 
  
  
  
  21.     } 
    22.

很明顯，我們能夠看到在getNext()方法內(nèi)部，對于類變量id有一個先取值后加一再賦值的過程。因此，我們可以很肯定的說Java中的自增操作不是原子性的。

4.也許你會問，那局部變量的自增操作是否是原子性的。好，我們在看看一下代碼：

 
 
 
    
  
  
  
  1. public class Increment {  
    2. 
  
  
  
  2.     public void getNext(){  
    3. 
  
  
  
  3.     int id = 0;  
    4. 
  
  
  
  4.         id++;  
    5. 
  
  
  
  5.     }  
    6. 
  
  
  
  6. } 
    7.

我們再看看反編譯之后的Java字節(jié)碼，主要還是關注getNext()方法內(nèi)部的Java字節(jié)碼。

 
 
 
    
  
  
  
  1. public class Increment extends java.lang.Object{  
    2. 
  
  
  
  2. public Increment();  
    3. 
  
  
  
  3.   Code:  
    4. 
  
  
  
  4. :   aload_0  
    5. 
  
  
  
  5. :   invokespecial   #1; //Method java/lang/Object."":()V  
    6. 
  
  
  
  6. :   return 
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8. public void getNext();  
    9. 
  
  
  
  9.   Code:  
    10. 
  
  
  
  10. :   iconst_0  
    11. 
  
  
  
  11. :   istore_1  
    12. 
  
  
  
  12. :   iinc    1, 1 
    13. 
  
  
  
  13. :   return 
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15. } 
    16.

與全局變量的自增操作相比，很明顯局部變量的自增操作少了getfield與putfield操作。而且對于局部變量來說，它無論如何都不會涉及到多線程的操作，因此局部變量的自增操作是否是原子操作也就顯得不那么重要了。


分享名稱：關于Java自增操作的原子性
標題鏈接：http://www.5511xx.com/article/djceesj.html