一、CAS
1.1 java层面的CAS
CAS：Compare And Swap，即比较再交换，实现并发算法时常用到的一种技术。
CAS操作包含三个操作数——内存位置、预期原值及新值。执行CAS操作的时候，将内存位置的值与预期原值比较，如果相匹配，那么处理器会自动将该位置值更新为新值，否则，处理器不做任何操作。我们都知道，CAS是一条CPU的原子指令（cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。
CAS操作是抱着乐观的态度进行的，它总是认为自己可以成功完成操作。当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。基于这样的原理，CAS操作即使没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。
在硬件层面，大部分的现代处理器都已经支持原子化的CAS指令。在JDK5以后，虚拟机便可以使用这个指令来实现并发操作和并发数据结构，并且这种操作在虚拟机中可以说是无处不在的。并且 jdk5还增加了并发包java.util.concurrent.atomic.*，其下面的类使用CAS算法来实现数据变更。
下面来看下java.util.concurrent.atomic.AtomicInteger的简单使用：
package com.wlw.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS ：compareAndSet() 这个方法的缩写 比较并交换！
public static void main(String[] args) {
//原子类的底层运用了CAS
AtomicInteger atomicInteger = new AtomicInteger(2020);
// public final boolean compareAndSet(int expect, int update)
//如果我期望的值达到了，那么就更新，否则，就不更新，CAS是CPU的并发原语!
System.out.println(atomicInteger.compareAndSet(2020, 2021)); //true
System.out.println(atomicInteger.get()); //2021 ,atomicInteger的值更新到了2021
System.out.println(atomicInteger.compareAndSet(2020, 2021)); //false
System.out.println(atomicInteger.get()); //2021，此时atomicInteger的值是2021，不更新
}
}
我们来看一下compareAndSet() 方法的源码 (AtomicInteger.java文件中)：
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
可以看到用到了 unsafe.compareAndSwapInt() 方法 (这是底层的CAS ,Unsafe.class中 )：
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
这里提到了unsafe类，我们来下这个类
1.2unsafe类
sun/misc/Unsafe.class源码：
/**
* CAS
* @param o 包含要修改field的对象
* @param offset 对象中某field的偏移量
* @param expected 期望值
* @param update 更新值
* @return true | false
*/
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object update);
public final native boolean compareAndSwapInt(Object o, long offset, int expected,int update);
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);
CAS在java.util.concurrent.atomic相关类、Java AQS、CurrentHashMap等实现上有非常广泛的应用。如下图所示，AtomicInteger的实现中，静态字段valueOffset即为字段value的内存偏移地址，valueOffset的值在AtomicInteger初始化时，在静态代码块中通过Unsafe的objectFieldOffset方法获取。在AtomicInteger中提供的线程安全方法中，通过字段valueOffset的值可以定位到AtomicInteger对象中value的内存地址，从而可以根据CAS实现对value字段的原子操作。
这里有一个unsafe ，先来看下它的定义，在 AtomicInteger.java文件中：
继续看下：AtomicInteger中有个执行+1操作的方法 getAndIncrement() ，它的源码如下：
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
然后我们看一下unsafe.getAndAddInt(this, valueOffset, 1); 这个方法 在这个文件（sun/misc/Unsafe.class）中：
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
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;
}
这个方法的解释：this就是当前对象赋值给var1，valueoffset是内存地址偏移值赋值给var2，1就是要加的值赋值给var4，通过var1和var2获取当前对象在内存中的值赋值给var5，然后通过compareAndSwapInt （CAS比较并交换,这是一个用native修饰的方法）这个方法来判断当前对象的内存地址偏移值中对应的值如果还是var5 （我期望的值），就执行加1。
下图为AtomicInteger对象自增操作前后的内存示意图，对象的基地址baseAddress=“0x110000”，通过baseAddress+valueOffset得到value的内存地址valueAddress=“0x11000c”；然后通过CAS进行原子性的更新操作，成功则返回，否则继续重试，直到更新成功为止。
补充下题外话，对于Unsafe类中的getAndAddInt这个方法，还用到了自选锁
1.3小结
- CAS：比较当前工作内存中的值 和 主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。
- CAS优点：自带原子性
- CAS缺点：
- 由于使用了自旋锁，循环会耗时；
- 一次性只能保证一个共享变量的原子性；
- 它会存在ABA问题（CAS实现原子操作的问题）
unsafe的CAS操作调用的是底层C++的方法，如果你看到底层的方法，会发现它依然是加锁的！也正是因为其足够底层，可以说是一条CPU的原子指令，其效率才会快。（所以可以说CAS对于java层面来说是无锁操作）
二、原子引用类解决ABA问题
2.1 ABA问题
在CAS算法中，需要取出内存中某时刻的数据(由用户完成)，在下一时刻比较并交换(CPU保证原子操作)，这个时间差会导致数据的变化。 假设有以下顺序事件： > 1、线程1从内存位置V中取出A > 2、线程2从内存位置V中取出A > 3、线程2进行了写操作，将B写入内存位置V > 4、线程2将A再次写入内存位置V > 5、线程1进行CAS操作，发现V中仍然是A，交换成功
尽管线程1的CAS操作成功，但线程1并不知道内存位置V的数据发生过改变
-
线程1：期望值是1，要把1变成2；
-
而线程2：进行了两个操作：
- 1、对变量A，进行了cas操作，期望值是1，变成3
- 2、之后又进行了一次cas操作，期望是3，变成1
-
所以对于线程1来说，A的值还是1，所以就出现了问题，骗过了线程1；
public class casDemo {
//CAS : compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//boolean compareAndSet(int expect, int update)
//期望值、更新值
//如果实际值 和 我的期望值相同，那么就更新
//如果实际值 和 我的期望值不同，那么就不更新
//===================捣乱的线程=================
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
//===================期望的线程=================
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
}
}
2.2原子引用类解决ABA问题
- 解决ABA问题，对应的思想：加版本号（或者称为时间戳），更新数据的时候，版本号递增
- java.util.concurrent.atomic 包下有个类 AtomicStampedReference（原子引用类），它有带版本号的 原子操作！，在进行cas操作时，除了比较期望的值以外，还会比较期望的版本号，如果版本号不同，则修改失败
package com.wlw.cas;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo02 {
public static void main(String[] args) {
AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<Integer>(1,1);
new Thread(()->{
int stamp = atomicInteger.getStamp(); //获取版本号
System.out.println("a1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(1, 2, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("a2=>"+atomicInteger.getStamp());
System.out.println(atomicInteger.compareAndSet(2, 1, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("a3=>"+atomicInteger.getStamp());
},"A").start();
//乐观锁的原理
new Thread(()->{
int stamp = atomicInteger.getStamp(); //获取版本号
System.out.println("b1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(1, 6,
stamp, atomicInteger.getStamp() + 1)); //输出false，因为版本号不一致
System.out.println("b2=>"+atomicInteger.getStamp());
},"B").start();
}
}
/*
a1=>1
b1=>1
true
a2=>2
true
a3=>3
false
b2=>3
*/
扫一扫
530
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
