JUC下的atomic包（java.util.concurrent.atomic，i++線程安全問題）

1. java.util.concurrent.atomic包

在Java5.0後，java.util.concurrent.atomic包下提供了常用的支持原子性操作的原子處理類，這些原子類內部提供的操作方法都是線程安全的volatile原子操作。主要用於高併發環境下的高效程序處理。裏面的值具有以下特性：

• volatile保證內存可見性
• CAS（Compare And Swap）算法保證數據的原子性

以AtomicInteger爲例看源碼：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    //獲取當前的值
    public final int get() {
        return value;
    }
    
    //取當前的值，並設置新的值
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
     
    //
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
	
    //獲取當前的值，並自增	
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    //自增，並獲取當前的值
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    public final int getAndUpdate(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    ......
    
}

2. CAS算法

CAS算法是硬件（操作系統）對於併發操作共享數據的一種支持；

CAS算法包含三個操作數：內存值V、預估值A、更新值B，當且僅當 V==A 時，V=B，否則，將不做任何操作。

注：爲什麼CAS算法比同步鎖的效率高呢？
CAS算法相當於一種樂觀鎖，當不會成功時，它不會放棄CPU的使用權，會不斷嘗試。比synchronized實現的悲觀鎖效率高。

3. 用AtomicInteger保證i++線程安全

i++的原子性問題：i++的操作實際上分爲三個步驟：讀—>改—>寫
第一步：讀取i
第二步：i+1
第三步：將增值加後的i賦值給之前的i

可以看出，i++的操作是非原子性的，存在線程安全性問題，可以用JUC包下的AtomicInteger類來解決這個問題，如下：

public class AtomicTest implements Runnable{

    private AtomicInteger i = new AtomicInteger();

    public int getI(){
        return i.incrementAndGet();//替代i++
    }

    @Override
    public void run(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getI());
    }

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();

        for(int i=0;i<10;i++){
            new Thread(atomicTest).start();
        }
    }
}

其中一次的輸出結果：

1
2
3
9
8
7
6
4
5
10

注：AtomicXXX的多個方法並不保證原子性，即只保證單個方法調用的原子性；