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类完成的。