一個沒有併發控制的計數器：

1. publicclass Counter implements Runnable {  
2.     privatestaticint count;  
3.     publicvoid run() {  
4.         System.out.println(Thread.currentThread().getName()   
5.                 + ":" + (++count));  
6.     }  
7.     publicstaticvoid main(String[] args){  
8.         Counter counter = new Counter();  
9.         Thread t1 = new Thread(counter);  
10.         Thread t2 = new Thread(counter);  
11.         Thread t3 = new Thread(counter);  
12.         Thread t4 = new Thread(counter);  
13.         t1.start();  
14.         t2.start();  
15.         t3.start();  
16.         t4.start();  
17.     }  
18. }  

有時執行正常，但是偶爾會出現如下執行結果：

1. Thread-1:2  
2. Thread-0:1  
3. Thread-2:3  
4. Thread-3:3  

這顯然和預期結果不太一樣，先用javap -verbose命令分析一下這個類，在位元組碼層面上，++count等價於虛擬機器順次執行如下5條位元組碼指令（不考慮執行期的優化）

1. getstatic  獲取指定類的靜態域，並將其值壓入棧頂  
2. iconst_1   將int型1推送至棧頂  
3. iadd       將棧頂兩int型數值相加並將結果壓入棧頂  
4. dup        複製棧頂數值並將複製值壓入棧頂  
5. putstatic  為指定類的靜態域賦值  

當Thread-3執行緒執行getstatic指令時，Thread-2執行緒還未執行至iadd指令，故Thread-3執行緒獲取的初始靜態域count的值和Thread-2執行緒一樣，都為2

本質原因就是++count雖然只是一行程式碼，但這一過程並非原子操作

要保證這種型別的原子操作，可以使用java.util.concurrent.atomic包下的類

1. 軟體包 java.util.concurrent.atomic   
2. 類的小工具包，支援在單個變數上解除鎖的執行緒安全程式設計。  

示例如下：

1. publicclass Counter implements Runnable {  
2.     privatefinal AtomicInteger count = new AtomicInteger(0);  
3.     publicvoid run() {  
4.         System.out.println(Thread.currentThread().getName()   
5.                 + ":" + count.incrementAndGet());  
6.     }  
7.     publicstaticvoid main(String[] args){  
8.         Counter counter = new Counter();  
9.         Thread t1 = new Thread(counter);  
10.         Thread t2 = new Thread(counter);  
11.         Thread t3 = new Thread(counter);  
12.         Thread t4 = new Thread(counter);  
13.         t1.start();  
14.         t2.start();  
15.         t3.start();  
16.         t4.start();  
17.     }  
18. }  

看看原始碼中究竟是如何實現的

1. privatevolatileint value;  
2. public AtomicInteger(int initialValue) {  
3.     value = initialValue;  
4. }  
5. publicfinalint incrementAndGet() {  
6.     for (;;) {  
7.         int current = get();  
8.         int next = current + 1;  
9.         if (compareAndSet(current, next))  
10.             return next;  
11.     }  
12. }  
13. /** 
14.     * Atomically sets the value to the given updated value 
15.     * if the current value {@code ==} the expected value. 
16.     * 
17.     * @param expect the expected value 
18.     * @param update the new value 
19.     * @return true if successful. False return indicates that 
20.     * the actual value was not equal to the expected value. 
21.     */
22. publicfinalboolean compareAndSet(int expect, int update) {  
23.     return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
24. }  
25. publicfinalint get() {  
26.   return value;  
27. }  

是不是和樂觀鎖很像，如果結果符合預期結果，就將結果返回，否則不斷進行重試，並沒有進行同步，兼顧了安全性和效能

java.util.concurrent.atomic包下還有很多類，使用這些類可以保證對這些類的諸如“獲取-更新”操作是原子性的，從而避發生競態條件

1. AtomicBoolean 可以用原子方式更新的 boolean 值。   
2. AtomicInteger 可以用原子方式更新的 int 值。   
3. AtomicIntegerArray 可以用原子方式更新其元素的 int 陣列。   
4. AtomicIntegerFieldUpdater<T> 基於反射的實用工具，可以對指定類的指定 volatile int 欄位進行原子更新。   
5. AtomicLong 可以用原子方式更新的 long 值。   
6. AtomicLongArray 可以用原子方式更新其元素的 long 陣列。   
7. AtomicLongFieldUpdater<T> 基於反射的實用工具，可以對指定類的指定 volatile long 欄位進行原子更新。   
8. AtomicMarkableReference<V> AtomicMarkableReference 維護帶有標記位的物件引用，可以原子方式對其進行更新。   
9. AtomicReference<V> 可以用原子方式更新的物件引用。   
10. AtomicReferenceArray<E> 可以用原子方式更新其元素的物件引用陣列。   
11. AtomicReferenceFieldUpdater<T,V> 基於反射的實用工具，可以對指定類的指定 volatile 欄位進行原子更新。   
12. AtomicStampedReference<V> AtomicStampedReference 維護帶有整數“標誌”的物件引用，可以用原子方式對其進行更新。