static volatile int NUMBER = 0; //volatile可以保證我們每次取值都是取內存的值（最新值），而不是取棧里面的緩存值
    private static void add() throws InterruptedException {
        Thread.sleep(5); //模擬線程處理數據
        NUMBER++;
    }
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(100);//柵欄，底層為AQS實現，當里面值變?yōu)?時，柵欄才打開繼續(xù)運行下面代碼
        Long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j<100; j++){
                        try {
                            add();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();//等待所有線程運行完
        System.out.println("最后執(zhí)行結果：" + NUMBER + "。執(zhí)行時間為：" + (System.currentTimeMillis() - start) + "ms");
    }
//最后執(zhí)行結果：9637。執(zhí)行時間為：600ms

    private synchronized static void add() throws InterruptedException {
        Thread.sleep(5);
       /**
         *  NUMBER++ 被拆分成三步
         *      1、從內存中獲取 NUMBER 的值，賦給 A : A = NUMBER
         *      2、對 A 進行 +1 得到 B： B = A + 1
         *      3、把 B 的值寫回 NUMBER：NUMBER = B
         * 在不加鎖的情況下，如果有A.B兩個線程同時執(zhí)行count++，他們通知執(zhí)行到上面步驟的第一步，得到count是一樣的，而當第 3 步操作結束后，count只加1，導致count結果不一致
         */
        NUMBER++;
    }
//最后執(zhí)行結果：10000。執(zhí)行時間為：56534ms

static volatile int NUMBER = 0;//共享資源
    private static void add() throws InterruptedException {
        Thread.sleep(5);
        /**
         *  NUMBER++ 被拆分成三步
         *      1、從內存中獲取 NUMBER 的值，賦給 A : A = NUMBER
         *      2、對 A 進行 +1 得到 B： B = A + 1
         *      3、把 B 的值寫回 NUMBER：NUMBER = B
         *      升級第三步：
         *          1、獲取鎖
         *          2、獲取 NUMBER 的最新值，記作LV
         *          3、判斷 LV 是否等于 A，如果相等，則將 B 的值賦給NUMBER，并且返回true，如果不相等返回false，線程再自旋請求修改值
         */
       int expectNumber;
       for (;;)//自旋修改，知道修改成功
           if (compareAndSwap((expectNumber=getNumber()),expectNumber+1))
                    break;
    }
    /**
     * 模擬底層 sun.misc.Unsafe 的 compareAndSwap 方法，所以這里我加了鎖，底層并不是加鎖，它的底層是native修飾的，是方法區(qū)的方法，由C或者C++寫的，它是對數據總線加鎖，synchronized是對字節(jié)碼加鎖。
     * @param expectNumber 期望值
     * @param newNumber 要交換的值
     * @return 返回交換是否成功
     */
    public static synchronized boolean compareAndSwap(int expectNumber, int newNumber){
        if (expectNumber == getNumber()){
            NUMBER = newNumber;
            return true;
        }
        return false;
    }
    public static int getNumber(){return NUMBER;}
//最后執(zhí)行結果：10000。執(zhí)行時間為：596ms

    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
	//var1：表示要訪問的對象，對象引用地址
	//var2：表示偏移量，即屬性再要訪問對象地址的偏移量
	//var4：表示要修改的數據的期望值
	//var5：表示要修改為的新值

//沒有版本號的情況
static AtomicInteger a = new AtomicInteger(1);
public static void main(String[] args) throws InterruptedException {
    System.out.println("初始值："+a.get());
    new Thread(new Runnable() {
        @Override
        public void run() {
            int expectNum = a.get();//拿到最初的值
            int newNum = expectNum+1;
            try {
                Thread.sleep(1000); //先休眠一會，保證是最后執(zhí)行的
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean isSuccess = a.compareAndSet(expectNum, newNum);
            System.out.println("主線程執(zhí)行結果：" + isSuccess + "，值為：" + a.get());
        }
    },"主線程").start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            a.incrementAndGet();
            System.out.println("干擾線程執(zhí)行結果："  + a.get());
            a.decrementAndGet();
            System.out.println("干擾線程執(zhí)行結果："  + a.get());
        }
    },"干擾線程").start();
}
/*
初始值：1
干擾線程執(zhí)行結果：2
干擾線程執(zhí)行結果：1
主線程執(zhí)行結果：ture，值為：2*/

    //initialRef為初始值，initialStamp為初始版本號
	public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
	/**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference             期望的引用
     * @param newReference the new value for the reference  		        引用的新值
     * @param expectedStamp the expected value of the stamp			期望的版本號
     * @param newStamp the new value for the stamp				新值的版本號
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&  
            expectedStamp == current.stamp &&
            //前兩個判斷當前的版本或者當前的值是否被改過，改過就直接返回false
            ((newReference == current.reference &&
              newStamp == current.stamp) 
             //上面兩個判斷當前的版本號和新值是否和要修改后的一致，一致就不進行修改
             //如果不一致，就修改當前的版本值和當前值
             ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1),1);
public static void main(String[] args) throws InterruptedException {
    System.out.println("初始值："+a.getReference());
    new Thread(new Runnable() {
        @Override
        public void run() {
            //獲取需要的參數
            int expectReference = a.getReference();
            int newReference = expectReference + 1;
            int expectStamp = a.getStamp();
            int newStamp = expectStamp + 1;
            try {
                Thread.sleep(1000);//睡眠保證最后執(zhí)行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //傳入我們之前拿到的期望版本號和期望的值
            boolean isSuccess = a.compareAndSet(expectReference, newReference, expectStamp, newStamp);
            System.out.println("主線程執(zhí)行結果：" + isSuccess + "，值為：" + a.getReference());
        }
    },"主線程").start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //模擬修改ABA模式
            a.compareAndSet(a.getReference(),a.getReference()+1,a.getStamp(),a.getStamp()+1);
            System.out.println("干擾線程執(zhí)行結果："  + a.getReference());
            a.compareAndSet(a.getReference(),a.getReference()-1,a.getStamp(),a.getStamp()+1);
            System.out.println("干擾線程執(zhí)行結果："  + a.getReference());
        }
    },"干擾線程").start();
}
/*
初始值：1
干擾線程執(zhí)行結果：2
干擾線程執(zhí)行結果：1
主線程執(zhí)行結果：false，值為：1*/