Java并发编程 - CAS 底层剖析

Java并发编程 - CAS 底层剖析

 

由volatile关键字可知，他可以保证JMM内存模型的可见性和有序性（禁止指令重排序）但是不能保证原子性，导致线程安全问题，我们可以加synchronized关键字来解决但是对于有些业务来说，synchronized太重了开销太大，所以我们可以用JUC包下的原子操作系列Atomic操作类，提供了操作的原子性。在底层的实现原理还是CAS。

CAS：

CAS就是Compare and Swap：比较并交换。

CAS一般有三个参数（要更新的数，预期值，新值）

如果当前要更新的数符合自己的预期值，那么该线程就将此值更新为新值，如果不符合预期，说明被其他线程改了，该线程不会挂起，而是会再次尝试或者结束。

多个线程对同一个变量进行CAS操作，只有一个线程能成功修改此值，但是失败的线程不会挂起而是继续尝试修改，这是一个乐观的过程，每个线程都希望自己能成功的改值，所以这也是乐观的一种无锁机制，因为没有锁，没有线程被挂起，所以这又是天生免疫死锁的。由于CAS是一种系统原语,原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许中断,也即是说CAS是一条原子指令,不会造成所谓的数据不一致的问题.

Atomic系列:

在JUC的Atomic操作类下能提供原子性操作，非常好用和高效：

随便写个小demo

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Demo {
    private volatile AtomicInteger number= new AtomicInteger(0);
    public   void add(){
        number.getAndIncrement();
    }
    public static void main(String[] args) {
        Demo d = new Demo();

        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                for (int j = 0; j < 200 ; j++) {

                        d.add();
                }
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(d.number);
    }
}

开100个线程对变量进行加一操作重复200次，在保证可见性的同时也保证原子性，线程安全！

运行结果是20000

来看看atomic的AtomicInteger的部分源码：

 private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }

    /**
     * Gets the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }

    /**
     * Sets to the given value.
     *
     * @param newValue the new value
     */
    public final void set(int newValue) {
        value = newValue;
    }

    /**
     * Eventually sets to the given value.
     *
     * @param newValue the new value
     * @since 1.6
     */
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

    /**
     * Atomically sets to the given value and returns the old value.
     *
     * @param newValue the new value
     * @return the previous value
     */
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

可以看得出所有原子性操作都是依赖Unsafe这个类来实现的，这里的valueOffset是内存偏移量，通过它，unsafe类可以直接从最底层操作数据。

Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，单从名称看来就可以知道该类是非安全的，毕竟Unsafe拥有着类似于C的指针操作，因此总是不应该首先使用Unsafe类，Java官方也不建议直接使用的Unsafe类，据说Oracle正在计划从Java 9中去掉Unsafe类，但我们还是很有必要了解该类，因为Java中CAS操作的执行依赖于Unsafe类的方法，注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
现在让我们看看demo中的AtomicInteger的getAndIncrement是如何实现原子操作的。

 /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

然后进入unsafe.getAndAddInt，得进入rt\sum\misc\才能找到该类的该方法：

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);//获取最新的快照值
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));//如果期望值不符，无法正常修改，就重新获取

        return var5;
    }

这个方法保证了操作的原子性，因为compareAndSwapInt是操作系统底层原语。

原子更新引用AtomicReference：

原子更新引用的道理和AtomicInteger一样，底层还是靠Unsafe类实现的，

public class AtomicReference<V> implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicReference.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    //内部变量value，Unsafe类通过valueOffset内存偏移量即可获取该变量
    private volatile V value;

//CAS方法，间接调用unsafe.compareAndSwapObject(),它是一个
//实现了CAS操作的native方法
public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
}

//设置并获取旧值
public final V getAndSet(V newValue) {
        return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
    }
    //省略其他代码......
}

//Unsafe类中的getAndSetObject方法，实际调用还是CAS操作
public final Object getAndSetObject(Object o, long offset, Object newValue) {
      Object v;
      do {
          v = getObjectVolatile(o, offset);
      } while (!compareAndSwapObject(o, offset, v, newValue));
      return v;
  }

CAS造成的ABA问题及解决：

        static AtomicInteger atomicInteger  = new AtomicInteger(100);//声明一个原子整型初始值为100
        new Thread(()->{
            atomicInteger.compareAndSet(100,101);//线程一期望值是100，改为101
            atomicInteger.compareAndSet(101,100);//期望值是101，又改回100

        },"t1").start();
        new Thread(()->{

            try {
                TimeUnit.SECONDS.sleep(1);//让线程一有充足的时间完成操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println( atomicInteger.compareAndSet(100,2019)+"\t"+atomicInteger.get());
        },"t2").start();//线程二再去将自己认为没动过的100改为2019
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

线程二希望拿到的是100，但是100经过线程一的两次操作，虽然还是100但是已经改变过了，线程二拿到的不是严格意义上的初始值，这就是ABA问题。

解决：

static int stamp = 1;
static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,stamp); 
new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"第一次获取的版本号："+ atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"第二次获取的版本号："+ atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"第三次获取的版本号："+ atomicStampedReference.getStamp());
        },"t1").start();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"第一次获取的版本号："+ atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"能否修改："+atomicStampedReference.compareAndSet(100,2018,stamp,stamp+1)+"当前的版本号是："+atomicStampedReference.getStamp()+"当前的实际值是："+atomicStampedReference.getReference());

        },"t2").start();

运行结果：

AtomicStampedReference

AtomicStampedReference原子类是一个带有时间戳的对象引用，在每次修改后，AtomicStampedReference不仅会设置新值而且还会记录更改的时间。当AtomicStampedReference设置对象值时，对象值以及时间戳都必须满足期望值才能写入成功，这也就解决了反复读写时，无法预知值是否已被修改的窘境。他的底层依旧是利用unsafe类完成的。