多執行緒併發協同通訊一直都是不可避之的話題，尤其是現代多核處理器的發展更推動了關於這方面的研究。

在JAVA領域，JDK 5之前是靠synchronized關鍵字保證同步的，而這會導致產生比較重量級的鎖，通常會導致執行緒阻塞、等待、喚醒。如果執行緒的這種狀態切換比較頻繁可能會加重CPU的負擔，這樣可能會阻礙真正有意義的處理。

而CAS這種演算法的出現可以避免這些，CAS是從硬體層面作一些變數操作的原子性強控，這些並不會導致JAVA執行緒的阻塞，你也可以理解它其實也有一把鎖，就是在比對更新的時候鎖住，但是這把鎖非常輕量化。
關於CAS的一些詳細原理、發展史、以及詳細說明，這裡不作解釋，不懂可以度娘。

今天只是初識了下JAVA的AtomicReference
以下是程式碼截圖，同時附上了相關理解說明：

package test.atomic.reference;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;

/**
 *
 * 該用例意在說明用CAS原理基於一個預期的值作更新時（更新後的值與預期值不一樣），
 * 我們可以保證從讀取判斷到更新值這一個過程是原子方式進行操作的，
 * 所以在多執行緒併發的時候只會有一個成功，因為後面的執行緒在作CAS時會發現預期值已經改變
 * 這可以避免對同一個域進行多次寫操作
 *
 * 注意點：多執行緒併發做該操作只會有一個成功
 *
 */
 

public class CompareAndSetTest {

    private static AtomicReference<Object> obj = new AtomicReference<>();

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100000; i++) {
            executorService.submit(new
 
 ObjReferenceHandler());
        }
        executorService.shutdown();
    }

    public static void printWrappedInfo(Object info, String type) {
        long id = Thread.currentThread().getId();
        System.out.println(id + ": [" + type + "] --> " + info);
    }

    public static void printBeforeObj(Object info) {
        printWrappedInfo(info, "before");
    }

    public static void printAfterObj(Object info) {
        printWrappedInfo(info, "after");
    }

    public static void printCASResult(Object info) {
        printWrappedInfo(info, "CAS");
    }


    static class ObjReferenceHandler implements Runnable {
        @Override
        public void run() {
            Object beforeObj = new Object();
            printBeforeObj(beforeObj);
            boolean b = obj.compareAndSet(null, beforeObj);
            printCASResult(b);
            Object afterObj = obj.get();
            printAfterObj(afterObj);
        }
    }
}

package test.atomic.reference;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;

/**
 *
 * 該用例意在用CAS原理基於當前值作更新，
 * 我們可以保證的是更新完成後，所作的更新是基於一個當前引用值作更新，而不是基於一個過期的引用值
 * 事實上我們並不關心當前引用值的具體狀態，我們能保證的是：併發更新時，從讀取、到經過運算、再到更新引用變數，這個流程最終會通過CAS，
 * 換名話說我們並不能保證這個流程一直是原子性的，但是終有一次通過了CAS，它一定是原子性的，而此時會中止嘗試，因為已經成功以原子方式更新了引用值
 *
 * 總的來說所有成功的操作才是有意義的，所有成功的操作在時間分片上一定是互不交叉的，最終保證了整體執行完成後，在最終效果上是同步的
 *
 * 注意點：對當前值不作任何預測，只是作CAS直到成功
 *
 */
public class UpdateAndGetTest {

    private static final AtomicReference<Integer> atomicInteger = new AtomicReference<>();


    static {
        atomicInteger.set(0);
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executorService.submit(new PlusNumber());
        }
        executorService.shutdown();
    }

    private static class PlusNumber implements Runnable {
        @Override
        public void run() {
            System.out.println(atomicInteger.updateAndGet(i -> i + 1));
        }
    }



}