Java多线程i++线程安全问题，volatile和AtomicInteger解释？

Question

在Java多线程中，i++和i--是非线程安全的。
例子：

public class PlusPlusTest {

    public static void main(String[] args) throws InterruptedException {
        Num num = new Num();
        ThreadA threadA = new ThreadA(num);
        ThreadB threadB = new ThreadB(num);
        threadA.start();
        threadB.start();
        Thread.sleep(200);
        System.out.println(num.count);
    }
}

class ThreadA extends Thread {
    private Num num;

    public ThreadA(Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            num.count++;
        }
    }
}

class ThreadB extends Thread {
    private Num num;

    public ThreadB(Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            num.count++;
        }
    }
}

class Num {
    int count = 0;

    public Num() {
    }
}

以上代码输出结果基本上不是2000，会比2000小。

原因：

在线程A中，i++的过程为：
temp1 = i; temp2 = temp1 + 1; i = temp2;
在线程B中，i++的过程为：
temp3 = i; temp4 = temp3 + 1; i = temp4;

在i=0的时候，线程A和B同时读取i=0。
线程A执行++后，i被修改成1。
线程B执行++后，i被修改，但还是1。

问：这样的解释对么？

想到把count变量申明为volatile，但是：

即使把count申明为volatile，输出的结果也不是2000，请问为什么？

class Num {
    volatile int count = 0;

    public Num() {
    }
}

最后

把count变量包装成AtomicInteger之后，输出的结果为2000，正确，这又是为什么？

Answer 1

因為volatile不保证操作的原子性，i++這種操作並不是原子操作。

Answer 2

問：這樣的解釋對麼？

其實不是很妥當，i++的操作應該沒有那麼麻煩，讀值是指讀到CPU。
出現錯誤，執行順序如下：

1. 线程1读到i的值为0，

2. 线程2也读到i的值为0，

3. 线程1执行了+1操作，将结果值1寫入到內存，

4. 线程2执行了+1操作，将结果值1寫入到記憶體。

即使把count申明為volatile，輸出的結果也不是2000，請問為什麼？

volatile只能保证可见性，就是说实时读到i的最新值，但不能保證原子性，即上述執行順序完全允許出現。這也可以參考我對這個問題的回答：https://segmentfault.com/q/10...

把count變數包裝成AtomicInteger之後，輸出的結果為2000，正確，這又是為什麼？

AtomicInteger是原子的int，这个是由Java實現的，大概理解下源碼：

 /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }
    
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

重點是compareAndSet()，這個方法會判斷current與i的值是否符合條件：此時i的值是否和current相等，滿足條件了直接退出循環，不然再++一遍，直到正常。 compareAndSet()，这个方法会判断current与i的值是否满足条件：此时i的值是否和current相等，满足条件了直接退出循环，不然再++一遍，直到正常。
compareAndSet方法是由Java的unsafe实现的，这个应该很底层了，都是native方法，我也没研究过。不过，一般程序员是不会接触到unsafecompareAndSet方法是由Java的unsafe實現的，這個應該很底層了，都是native方法，我也沒研究過。不過，一般程式設計師是不會接觸到unsafe程式設計的。

Answer 3

volatile只能保證可見性，即別人修改了之後你立刻能讀到，但是你改的時候別人也可以改。
AtomicInteger是基於CAS（Compare And Swap）的。

CAS有3個操作數，記憶體值V，舊的預期值A，要修改的新值B。當且僅當預期值A和記憶體值V相同時，將記憶體值V修改為B，否則什麼都不做。 兩個問題： （1）CAS演算法仍然可能會出現衝突，例如A、B兩個線程，A已經進入寫內存但未完成，此時A讀取到的副本且讀取成功，AB兩個線程同時進入寫記憶體操作，必然會造成衝突。 CAS演算法本質並非完全無鎖，而是把獲得鎖和釋放鎖推遲至CPU原語實現，相當於盡可能的縮小了鎖的範圍；直接互斥地實現系統狀態的改變，它的使用基本思想是copy-on-write－在修改完物件的副本之後再用CAS操作將副本替換為正本。 （2）ABA問題，若其中一個線程修改A->B->A，另外一個線程仍然讀取到A，雖然值是預期值，但並不能說明該內存值沒有變化。

Answer 4

懶的寫答案了，給一個非常好的文章Java並發程式設計：volatile關鍵字解析

Answer 5

volatile保證每次得到的資料是最新的（從記憶體中讀取），i++; --> i=i+1; 如果執行到i+1沒有賦值給i的話，就無法保證另一個執行緒得到的數據是最新的，後面那個是原子操作，所以能夠保證i＝這一定會執行