是什麽

• 全稱compare and swap，一個CPU原子指令，在硬件層面實現的機制，體現了樂觀鎖的思想。
• JVM用C語言封裝了匯編調用。Java的基礎庫中有很多類就是基於JNI調用C接口實現了多線程同步更新的功能。

原理

CMS有三個操作數：當前主內存變量的值V，線程本地變量預期值A，線程本地待更新值B。當需要更新變量值的時候，會先獲取到內存變量值V然後很預期值A進行比較，如果相同則更新為B，如果不同，則將最新的變量值更新到預期值中再重新嘗試上面的步驟，直到成功為止。

舉例

以基於CAS實現的AtomicInteger 類進行講解。

我們先寫一個多線程，對同一個數據類進行分別進行加減操作10000次，正確的結果應該還是0。

沒有任何多線程同步機制的代碼如下：

package priv.nanjing.testCasClass;

/*
 * @Author : darrenqiao
 * */

//多線程爭用的數據類
class Counter {
    int count = 0;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public void add() {
        count 
 
+= 1;
    }

    public void dec() {
        count -= 1;
    }
}

//爭用數據做加操作的線程
class AddDataThread extends Thread {

    Counter counter;

    public AddDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < CasClass.LOOP; ++i) {
            counter.add();
        }
    }
}

 
//爭用數據做減法操作的線程
class DecDataThread extends Thread {

    Counter counter;

    public DecDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int j = 0; j < CasClass.LOOP; j++) {
            counter.dec();
        }
    }
}

public class CasClass {
    final static int LOOP = 10000;

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread addThread = new AddDataThread(counter);
        Thread decThread = new DecDataThread(counter);
        addThread.start();
        decThread.start();
        addThread.join();
        decThread.join();
        System.out.println(counter.getCount());
    }

}

以下是三次執行結果，每一次都不一樣。

為什麽會出現這個結果呢？

因為 count += 1 / count -= 1 通過javap反編譯Count.class文件，可以看出對應的字節碼是三條指令

      //count += 1
       5: iconst_1
       6: iadd
       7: putfield      #12                 // Field count:I

     //count 1= 1
       5: iconst_1
       6: isub
       7: putfield      #12                 // Field count:I

所以多線程切換是，可能會造成數據更新的不同步，怎麽解決呢？

就是對被操作的數據加鎖，可以是悲觀鎖，可以是樂觀鎖，這裏使用的就是基於樂觀鎖實現的AtomicInteger類

package priv.nanjing.testCasClass;

import java.util.concurrent.atomic.AtomicInteger;

/*
 * @Author : darrenqiao
 * */


//多線程爭用的數據類
class Counter {
    //int count = 0;
    //使用AtomicInteger代替基本數據類型
    AtomicInteger count = new AtomicInteger(0);

    public int getCount() {
        //return count;
        return count.get();
    }


    public void add() {
        //count += 1;
        count.addAndGet(1);
    }

    public void dec() {
        //count -= 1;
        count.decrementAndGet();
    }
}

//爭用數據做加操作的線程
class AddDataThread extends Thread {

    Counter counter;

    public AddDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < CasClass.LOOP; ++i) {
            counter.add();
        }
    }
}

//爭用數據做減法操作的線程
class DecDataThread extends Thread {

    Counter counter;

    public DecDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int j = 0; j < CasClass.LOOP; j++) {
            counter.dec();
        }
    }
}

public class CasClass {
    final static int LOOP = 10000;

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread addThread = new AddDataThread(counter);
        Thread decThread = new DecDataThread(counter);
        addThread.start();
        decThread.start();
        addThread.join();
        decThread.join();
        System.out.println(counter.getCount());
    }

}

執行多次，會發現，結果只有一個：0.這樣就保證了數據更新的原子性。

那麽CAS有什麽缺點需要註意？

• ABA問題：我內存對象從A變成B在變成A，CAS會當成沒有變化，進而去更新值，實際是有變化的。
• 循環時間開銷大：一直和預期值不對的情況下，會一直循環。
• 只能保證一個共享變量的原子操作。

JAVA樂觀鎖實現-CAS