CAS的实现和底层原理

先来举个例子吧，引入CAS的使用

package cn.nlg.day07;

public class CASTest {
    private static int count =0;
    public static void main(String[] args) {
        System.out.println(getCount());
    }
    // 1000个线程同时操作count
    public static int getCount(){
        for (int i = 1; i <=1000; i++) {
            new Thread(()->{
                count++;
            },String.valueOf(i)).start();
        }
        return count;
    }
}

控制台输出：

以上程序很显然不是线程安全的，因为count++不是原子性操作

这时候直接想到加锁（Synchronized or ReentrantLock）

都不用，这时我们用类似CAS的原理来实现（CAS的底层当然更复杂）

        

package cn.nlg.day07;

import java.util.concurrent.CountDownLatch;

public class CASTest {
    private static volatile int count =0; //大家可以去看一下volatile关键字的作用
    public static void main(String[] args) throws InterruptedException {
        int count1 = getCount();
        System.out.println("---------------------");
        System.out.println(count1);
    }
    public static int returnCount(){
        return count;
    }
    public static synchronized boolean CASMethod(int expectValue,int newValue){
        if (returnCount()==expectValue){
            count=newValue;
            return true;
        }else {
            return  false;
        }
    }
    // 1000个线程同时操作count
    public static int getCount() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        for (int i = 1; i <=1000; i++) {
            new Thread(()->{
               while (!CASMethod(returnCount(),returnCount()+1)){
               }
                System.out.println(Thread.currentThread().getName()+"--->"+returnCount());
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
            countDownLatch.await();
        return count;
    }
}

控制台：

 

这样解决了

CAS 全称：CompareAndSwap，比较并交换

CAS有三个操作值：内存值V，预期值A，要修改的值B，当且仅当预期值A等于当前内存值V的时候，才将内存值更新为B。

当然JDK 提供了对CAS操作支持，在sun.misc.unsafe类中，主要这三个方法 

CAS存在哪些问题呢？？？

1）大量的占用cpu的资源

2）只能对一个变量进行操作

3）ABA问题

什么是ABA问题呢？？？

举个例子吧，有两个线程t1和t2，想要修改内存中的一个值，比如A，这时候t1先执行，准备判断是否与期望值是否相等时，这时候线程挂起了，这时候t2线程开始执行，将A值改为了B值，然后又将B值改为了A值，这时候t1开始操作了，他判断内存中的A值与期望值相等，于是修改成功，其实是已经被修改过了，这就是ABA问题

解决方案：加入版本号

不但要判断原值是否相等，还要判断版本号是否相等

JDK 提供了AtomicStampReference<?> 可解决