【锁】--CAS机制

一、CAS来源及定义

static int count = 0;
//这种方法是线程不安全的，最终的结果值会小于200
private void way1(){
    for (int i = 0; i < 2; i++){
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int j = 0; j < 100; j++){
                    count ++;
                }
            }
        }).start();
    }
}
//synchronized，虽然能保证线程安全，但性能比较低
private void way2(){
    for (int i = 0; i < 2; i++){
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int j = 0; j < 100; j++){
                    synchronized(CasOrigin.this){//这是类锁
                        count ++;
                    }
                }
            }
        }).start();
    }
}

--------在上面的例子中，虽然有同步锁保证线程安全，但影响性能。我们可以采用Java中原子操作类实现高效率的线程安全。

1、CAS定义

CAS：Compare And Swap，比较并替换。
CAS机制最少使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
CAS机制具有4个基本操作数：内存地址V，旧的预期值A，要修改的新值B、版本号【解决ABA问题】。

CAS机制原理：每个线程并发去操作，当某个线程在更新替换前，比较内存地址的数据和旧预期的不一样，那么就重新去获取，再次更新替换【重复尝试的过程叫自旋】。
Synchronized属于悲观锁，悲观地认为程序中的并发情况严重，所以严防死守。CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去尝试更新。

2、CAS缺点

CPU开销较大。并发量大情况下，反复尝试更新某个变量，却又一直更新不成功，循环往复，会给CPU带来很大压力。
不能保证代码块的原子性，只能保证一个变量的原子性。对于代码块原子性，还需要用sunchronized。

二、CAS的隐患----ABA问题

当一个值从A更新成B，又更新会A，普通CAS机制会误判通过检测。如下例子说明：
手机支付扣钱【原有100元，变成50元】时，由于网络卡顿，提交了两个线程。这两个线程的目的都是为了将100元扣成50元。实际中如果一个线程卡顿了，另一个线程已经完成操作，那么卡顿的其实应该是作废了。在线程卡顿期间，另一个线程给汇款50元，那么就变成100元。接着卡顿的线程好了，对比发现旧预值一样，会更新变成50元。导致钱异常少了50元。

----------------利用版本号比较可以有效解决ABA问题。不仅比较旧的预期值，还要比较版本号才能更新。

-----此时CAS机制应该具有四个基本操作数：内存地址V，旧的预期值A，要修改的新值B、版本号。

1、AtomicStampedReference—带版本号CAS

AtomicStampedReference源码如下

public class AtomicStampedReference<V> {
    //AtomicStampedReference类创建一个内部类，
    private static class Pair<T> {
        final T reference;  //维护对象引用
        final int stamp;  //用于标志版本
        private Pair(T reference, int stamp) {
		//私有构造函数
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
		//由类内部去实例化，外面通过类去调用
            return new Pair<T>(reference, stamp);
        }
    }
    private volatile Pair<V> pair;

    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
}

具体使用的例子

public class AtomicStampedReferenceTest {
    //维护对象引用，用于标志版本
    private static AtomicStampedReference<Integer> atomicStampedRef =
            new AtomicStampedReference<>(1, 0);
    /**
     * > 操作线程Thread[主操作线程,5,main],初始值 a = 2
     > 操作线程Thread[干扰线程,5,main],【increment】 ,值 = 2
     > 操作线程Thread[干扰线程,5,main],【decrement】 ,值 = 1
     > 操作线程Thread[主操作线程,5,main],CAS操作结果: false
     */
    public void test1(){
        Thread main = new Thread(() -> {
            System.out.println("操作线程" + Thread.currentThread() +",初始值 a = " + atomicStampedRef.getReference());
            int stamp = atomicStampedRef.getStamp(); //获取当前标识别
            try {
                Thread.sleep(1000); //等待1秒 ，以便让干扰线程执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean isCASSuccess = atomicStampedRef.compareAndSet(1,2,stamp,stamp +1);
            //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败
            System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);
        },"主操作线程");

        Thread other = new Thread(() -> {
            Thread.yield(); // 确保thread-main 优先执行
            atomicStampedRef.compareAndSet(1,2,atomicStampedRef.getStamp(),atomicStampedRef.getStamp() +1);
            System.out.println("操作线程" + Thread.currentThread() +",【increment】 ,值 = "+ atomicStampedRef.getReference());
            atomicStampedRef.compareAndSet(2,1,atomicStampedRef.getStamp(),atomicStampedRef.getStamp() +1);
            System.out.println("操作线程" + Thread.currentThread() +",【decrement】 ,值 = "+ atomicStampedRef.getReference());
        },"干扰线程");
        main.start();
        other.start();
    }

三、CAS底层实现

利用unsafe提供了原子性操作方法。CAS操作，通过内存偏移地址修改变量值。

Unsafe类是在sun.misc包下，不属于Java标准。但是很多Java的基础类库，包括一些被广泛使用的高性能开发库都是基于Unsafe类开发的，比如Netty、Hadoop、Kafka等。
使用Unsafe可用来直接访问系统内存资源并进行自主管理，Unsafe类在提升Java运行效率，增强Java语言底层操作能力方面起了很大的作用。Unsafe提供硬件级别的原子操作。
Unsafe可认为是Java中留下的后门，提供了一些低层次操作，如直接内存访问、线程调度等。
官方并不建议使用Unsafe。

Unsafe的直接内存访问：用Unsafe开辟的内存空间不占用Heap空间，当然也不具有自动内存回收功能。做到像C一样自由利用系统内存资源。

Unsafe的大部分API都是native的方法，主要包括以下几类：
1）Class相关。主要提供Class和它的静态字段的操作方法。
2）Object相关。主要提供Object和它的字段的操作方法。
3）Arrray相关。主要提供数组及其中元素的操作方法。
4）并发相关。主要提供低级别同步原语，如CAS、线程调度、volatile、内存屏障等。
5）Memory相关。提供了直接内存访问方法（绕过Java堆直接操作本地内存），可做到像C一样自由利用系统内存资源。
6）系统相关。主要返回某些低级别的内存信息，如地址大小、内存页大小。

四、CAS机制的应用

1、Atomic原子操作类

原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类。例如AtomicBoolean，AtomicInteger，AtomicLong。它们分别用于Boolean，Integer，Long类型的原子性操作。

private static final Unsafe unsafe = Unsafe.getUnsafe(); //提供硬件级别的原子操作
    private static final long valueOffset;//获取AtomicInteger对象的value成员变量的内存偏移量【内存地址】
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
private volatile int value;

(1)AtomicInteger—修改一个属性

主要是对某个变量保持原子性，在linkedBlokingQueue队列源码中就使用到这个。

//Unsafe直接操作内存空间
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;  //偏移量【获取该变量的内存分配的位置】
    private volatile int value;  //volatile同步机制，不能保证原子性.但通过Unsafe类直接操作内存，可以达到效果
    static {
        try {
            返回给定的非静态属性在它的类的存储分配中的位置(偏移地址)。
            valueOffset = unsafe.objectFieldOffset
                    (AtomicIntegerSumulate.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    public AtomicIntegerSumulate(){}
    public AtomicIntegerSumulate(int initialValue) {
        value = initialValue;
    }
    public final int get() {
        return value;
    }
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    //增加指定元素[可正可负]
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
    //比较设置值
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

2、AtomicReference类

并发修改多属性： 通过比对两个对象，然后更新为新的对象。
下面就是利用AtomicReference实现的单例设计模式。

public class CASSingleton {
    private static final AtomicReference<CASSingleton> INNERCAS = new AtomicReference<CASSingleton>();
    private CASSingleton(){} //私有的构造函数，表明不能外界初始化，而是内部方法初始化
    /**
     * CAS缺点：如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。
     * @return
     */
    public static CASSingleton getInstance(){
       for(;;){  //自旋循环
           CASSingleton singleton = INNERCAS.get();
           if(null != singleton){
               return singleton;
           }
           /**
            * 如果N个线程同时执行到singleton = new Singleton();的时候，会有大量对象创建，很可能导致内存溢出。
            */
           singleton = new CASSingleton();
           //只要new了，线程陆续推出
           if(INNERCAS.compareAndSet(null,singleton))
               return singleton;
       }
    }
}