Java的揮發性，同步，原子例如

Question

您好我正在讀Java併發在實踐中，我讀有趣的說法指出，

鎖定既能保證可見性和原子;易變的 變量只能保證能見度。

任何一個可以請解釋，如果變量聲明爲揮發性所有其他線程讀取更新獲得價值那就是爲什麼我關心像聲明中的原子：counter = counter + 1;

在此先感謝。

Answer 1

volatile關鍵字的效果大約是每個單獨的讀或寫操作在該變量是原子的。但是，值得注意的是，需要多個讀/寫操作的操作 - 例如i ++，相當於i = i + 1，它執行一次讀取和一次寫入 - 不是原子的，因爲另一個線程可能會在讀和寫之間寫入i。

的原子類，像的AtomicInteger和的AtomicReference，提供更廣泛的各種操作的原子，具體包括增量的AtomicInteger。

這就是爲什麼你需要關心的原子像反陳述=計數器+ 1

請查看這篇文章Volatile Vs Atomic

Answer 2

以下是一個演示這一動盪對自己是不是一個自包含例如可執行應用程序足夠。四個線程每次增加一個計數器10,000次，所以你最終預計該計數器爲40,000。它使用一個原始的int變量和一個AtomicInt，並且每次嘗試5次這個練習。

import java.util.Collections; 
import java.util.concurrent.*; 
import java.util.concurrent.atomic.AtomicInteger; 

class AtomicDemo { 
    interface Demo extends Callable<Void> { 
     int getCounter(); 
    } 

    static class UsePrimitive implements Demo { 
     private volatile int counter = 0; 

     public Void call() throws Exception { 
      for (int i = 1; i <= 10000; ++i) { 
       ++counter; 
      } 
      return null; 
     } 

     public int getCounter() { 
      return counter; 
     } 
    } 

    static class UseAtomic implements Demo { 
     final AtomicInteger counter = new AtomicInteger(0); 

     public Void call() throws Exception { 
      for (int i = 1; i <= 10000; ++i) { 
       counter.incrementAndGet(); 
       System.out.print(""); 
      } 
      return null; 
     } 

     public int getCounter() { 
      return counter.get(); 
     } 
    } 

    public static void main(String[] args) throws Exception { 
     ExecutorService exec = Executors.newFixedThreadPool(4); 
     for (int i = 1; i <= 5; ++i) { 
      Demo demo = new UsePrimitive(); 
      exec.invokeAll(Collections.nCopies(4, demo)); 
      System.out.println("Count to 40000 using primitive, attempt number " + i + ": " + demo.getCounter()); 
     } 
     for (int i = 1; i <= 5; ++i) { 
      Demo demo = new UseAtomic(); 
      exec.invokeAll(Collections.nCopies(4, demo)); 
      System.out.println("Count to 40000 using atomic, attempt number " + i + ": " + demo.getCounter()); 
     } 
     exec.shutdownNow(); 
    } 
} 

典型輸出：

Count to 40000 using primitive, attempt number 1: 39711 
Count to 40000 using primitive, attempt number 2: 39686 
Count to 40000 using primitive, attempt number 3: 39972 
Count to 40000 using primitive, attempt number 4: 39840 
Count to 40000 using primitive, attempt number 5: 39865 
Count to 40000 using atomic, attempt number 1: 40000 
Count to 40000 using atomic, attempt number 2: 40000 
Count to 40000 using atomic, attempt number 3: 40000 
Count to 40000 using atomic, attempt number 4: 40000 
Count to 40000 using atomic, attempt number 5: 40000 

你看，只有AtomicInt你總是得到預期的結果。