本文根据小刘老师视频而出:Java并发基石-CAS原理实战
在学习 CAS 之前,先从一个简单的 案例入手,进而引出 CAS 的基本使用。
基于 CAS 的网站计数器
需求:我们开发一个网站,需要对访问量进行统计,用户每发送一次请求,访问量 + 1,如何实现?
我们模拟有 100 个人同时访问,并且每个人对咱们的网站发起 10 次请求,最后总访问次数应该是 1000次
1.1、网站访问统计 Demo
/**
* @author wcc
* @date 2022/1/6 13:45
*/
public class Demo {
// 总访问量
static int count = 0;
// 模拟访问的方法
public static void request() throws Exception{
// 模拟耗时5毫秒钟
TimeUnit.MILLISECONDS.sleep(5);
count ++;
}
public static void main(String[] args) throws InterruptedException {
// 开启时间
long startTime = System.currentTimeMillis();
int threadSize = 100; // 用于模拟用户的人数
CountDownLatch countDownLatch = new CountDownLatch(threadSize);
for (int i = 0; i < threadSize; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 模拟用户行为,每个用户访问10次网站
for (int j = 0; j < 10; j++) {
request();
}
}catch (Exception e){
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
}
});
thread.start();
}
// 怎么保证100个线程执行结束之后,再执行后面的代码?
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + ":耗时:" + (endTime - startTime) + ",count:" + count);
}
}
这里先对 CountDownLatch 做一个简单的介绍,之后会更新一篇它的源码分析:
- CountDownLatch 的概念:
- CountDownLatch 是一个同步工具类,用来协调多个线程之间的同步,或者说起到线程之间的通信(而不是用作互斥的作用)。
- CountDownLatch 能够使一个线程再等待另外一些线程完成各自的工作之后,再继续执行。使用一个计数器实现。计数器初始值为线程的数量。当每一个线程完成自己的任务后,计数器的值就会减一。当计数器的值为 0 的时候,表示所有的线程都已经完成了任务,然后再 CountDownLatch 上等待的线程就可以恢复继续执行任务。
- CountDownLatch 的用法:
- CountDownLatch 的典型用法1:某一线程再开始运行前等待 n 个线程执行完毕。将 CountDownLatch 的计数器初始化为 n -> new CountDownLatch(n),每当一个任务线程执行完毕,就将计数器减一 -> countDownLatch.countDown(),当计数器的值变为 0 的时候,在 countDownLatch.await() 之后的线程就会被唤醒。一个典型应用场景就是启动一个服务的时候,主线程需要等待多个组件加载完毕,之后再继续执行。
- CountDownLatch 典型用法2:实现多个线程开始执行任务的最大并行性。注意是并行性,不是并发,强调的是多个线程再某一时刻同时开始执行。类似赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。做法是初始化一个共享的 CountDownLatch(1) ,将其计数器初始化为 1,多个线程再开始执行任务前首先 countDownLatch.await() ,当主线程调用 countDown() 的时候,计数器变为 0,多个线程被同时唤醒。
上面案例代码执行结果如下图:
如图所示,我们理论上开启了 100 个线程模拟用户,每个线程模拟访问 10 次,最终结果 count
应该是 1000 才对,但是无论怎么测试,最终 count
几乎都达不到 1000 次。
原因分析
/**
* Q:分析一下问题出在哪里:
* A:count++ 操作实际上是由三步操作来完成的
* 1.获取count的值,记作A:A=count
* 2.将A值+1,得到B,B=A+1
* 3.将B值赋值给count
*
* 如果有A、B两个线程,同时执行count++,他们同时执行到上面步骤的第一步,得到的count是一样的
* 三步操作执行结束后,count只加1,导致count结果不正确
*
* Q:怎么解决结果不正确的问题:
* A:对count++操作的时候,我们让多个线程排队处理,多个线程同时到达request()方法的时候
* 只能允许一个线程可以进去操作,其他的线程再外面等待,等里面的线程处理完毕后,外面的线程再开始竞争该方法的
* 执行权,这样操作的count++ 就是排队进行的,结果一定是正确的
*
* Q:怎么实现排队效果?
* A:JAVA 中的synchronized 关键字(加锁)和 ReentrantLocak都可以实现对资源加锁,保证并发的正确性
* 多线程的情况下可以保证被锁住的资源被串行访问
*/
1.2、使用 Synchronized 关键字改进 Demo 案例
改进代码如下:
/**
* @author wcc
* @date 2022/1/6 13:45
*/
public class Demo {
// 总访问量
static int count = 0;
// 模拟访问的方法
public synchronized static void request() throws Exception{
// 模拟耗时5毫秒钟
TimeUnit.MILLISECONDS.sleep(5);
count ++;
}
public static void main(String[] args) throws InterruptedException {
// 开启时间
long startTime = System.currentTimeMillis();
int threadSize = 100; // 用于模拟用户的人数
CountDownLatch countDownLatch = new CountDownLatch(threadSize);
for (int i = 0; i < threadSize; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 模拟用户行为,每个用户访问10次网站
for (int j = 0; j < 10; j++) {
request();
}
}catch (Exception e){
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
}
});
thread.start();
}
// 怎么保证100个线程执行结束之后,再执行后面的代码?
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + ":耗时:" + (endTime - startTime) + ",count:" + count);
}
}
执行案例代码结果如下:
可以看出,我们要得到总访问量 1000 结果正确,但是当我们把 synchronized
关键字加在了 request()
方法上,由于锁住了方法,导致相比于不加锁的时候,线程执行效率严重降低!
原因分析
/**
* Q:耗时太长的原因是什么?
* A:程序中的 request()方法使用synchronized 关键字修饰,保证了并发情况下,request方法同一时刻
* 只允许一个线程进入,request方法加锁相当于串行执行了,count的结果和我们预期的一致,但是耗时太长了..
*
* Q:如何解决耗时太长的问题:
* A:count++ 操作实际上是由三步操作来完成的
* 1.获取count的值,记作A:A=count
* 2.将A值+1,得到B,B=A+1
* 3.将B值赋值给count
* 升级第三步的实现:
* 1.获取锁
* 2.获取一下count最新的值,记作LV
* 3.判断LV的值是否等于A,如果相等,则将B的值赋值给count,并返回true,否则的话返回false
* 4.释放锁
*/
1.3、缩小加锁范围再次改进 Demo 案例
package cas;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* @author wcc
* @date 2022/1/6 13:45
*/
public class Demo01 {
// 总访问量
// 加上volatile关键字,代表每次获取count的值都要去主内存中去取,而不是取获取当前线程中缓存的count值
volatile static int count = 0;
// 模拟访问的方法
public static void request() throws Exception{
// 模拟耗时5毫秒钟
TimeUnit.MILLISECONDS.sleep(5);
int expectCount; // 期望值:表示线程进入方法的时候count的值
while (!compareAndSwap((expectCount = getCount()),expectCount + 1)){
}
}
/**
* @param expectedCount 期望值
* @param newCount 需要给count赋值的新值
* @return 成功返回true,失败返回false
*/
public static synchronized boolean compareAndSwap(int expectedCount, int newCount){
// 判断一下count当前值是否和期望的expectedCount一致,如果一致,则将newCount赋值给count
if(getCount() == expectedCount){
count = newCount;
return true;
}
return false;
}
public static int getCount(){
return count;
}
public static void main(String[] args) throws InterruptedException {
// 开启时间
long startTime = System.currentTimeMillis();
int threadSize = 100; // 用于模拟用户的人数
CountDownLatch countDownLatch = new CountDownLatch(threadSize);
for (int i = 0; i < threadSize; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 模拟用户行为,每个用户访问10次网站
for (int j = 0; j < 10; j++) {
request();
}
}catch (Exception e){
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
}
});
thread.start();
}
// 怎么保证100个线程执行结束之后,再执行后面的代码?
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + ":耗时:" + (endTime - startTime) + ",count:" + count);
}
}
案例代码执行结果如下:
可以看到这种方式下,不仅可以达到期望的网站访问量结果,效率也很高!
这种 比较并交换
且线程安全的方式就可以称作 CAS:
/**
* @param expectedCount 期望值
* @param newCount 需要给count赋值的新值
* @return 成功返回true,失败返回false
*/
public static synchronized boolean compareAndSwap(int expectedCount, int newCount){
// 判断一下count当前值是否和期望的expectedCount一致,如果一致,则将newCount赋值给count
if(getCount() == expectedCount){
count = newCount;
return true;
}
return false;
}
2、CAS 的介绍和实现原理
- CAS 全称 “CompareAndSwap”,中文翻译过来为 “比较并替换”。
- 定义:
- CAS 操作包含三个操作数 ---- 内存位置(V)、期望值(A)和新值(B)。
- 如果内存位置的值与期望值匹配,那么处理器会自动将该位置的值更新为新值。否则,处理器不做任何操作。
- 无论哪种情况,它都会在 CAS 指令之前返回该位置的值,(CAS 在一些特殊情况下仅仅返回 CAS 是否成功,而不提取当前值)
- CAS 有效的说明了 “我认为位置 V 应该包含值 A;如果包含该值,则将 B 放到这个位置;否则,不要更改该位置的值,只告诉我这个位置现在的值即可”
2.1、JAVA 中的 CAS
JAVA 中提供了对 CAS 操作的支持,具体在 sun.misc.unsafe
类中,声明如下:
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
- 参数 var1:表示要操作的对象
- 参数 var2:表示要操作对象中属性地址的偏移量
- 参数 var4:表示需要修改数据的期望的值
- 参数 var5:表示需要修改为的新值
CAS 的实现原理是什么?
JAVA 中的 CAS 通过调用 JNI 的代码实现,JNI:JAVA NATIVE INTERFACE,允许JAVA 调用其他语言。而 compareAndSwapXXX
系列的方法就是借助 C 语言来调用 CPU 底层指令实现的。
以常用的 Intel X86 平台来说,最终映射到的 CPU 的指令为 cmpxchg
,这是一个原子指令,CPU 执行此命令的时候,实现比较并替换的操作!
现代的计算机动不动就是上百核心,cmpxchg 怎么保证多核心下的线程安全?
系统底层进行 CAS 操作的时候,会判断当前系统是否为多核心系统,如果是就会给总线加锁,只有一个线程会对总线加锁成功,加锁成功之后会执行 CAS 操作,也就是说 CAS 的原子性是平台级别的。
2.2、CAS 也会出现一些问题
2.2.1、ABA 问题(狸猫换太子)
CAS 需要在操作值得时候检查下值有没有发生变化,如果没有发生变化则更新,但是如果一个值原来是 A,在 CAS 方法执行之前,被其他线程修改为了 B、然后又修改回去了A,那么CAS 方法执行检查得时候会发现它得值有没有发生变化,但是实际却发生变化了。这就是 CAS 得 ABA 问题。
使用程序模拟 ABA 问题:
/**
* @author wcc
* @date 2022/1/6 15:58
*/
public class CasABA {
public static AtomicInteger a = new AtomicInteger(1);
public static void main(String[] args) {
Thread main = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("操作线程:"+ Thread.currentThread().getName()+",初始值:"+a.get());
try {
int expectNum = a.get(); // 期望值
int newNum = expectNum + 1; // 新值
Thread.sleep(1000); // 主线程休眠1秒钟,让出CPU
boolean isCASSuccess = a.compareAndSet(expectNum, newNum);
System.out.println("操作线程:"+Thread.currentThread().getName()+",CAS 操作:"+isCASSuccess);
}catch (Exception e){
e.printStackTrace();
}
}
},"主线程");
Thread other = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(20); // 确保main主线程优先执行
a.incrementAndGet(); // a+1 a=2
System.out.println("操作线程:"+Thread.currentThread().getName()+",[increment],值="+a.get());
a.decrementAndGet(); // a-1 a=1
System.out.println("操作线程:"+Thread.currentThread().getName()+",[decrement],值="+a.get());
}catch (Exception e){
e.printStackTrace();
}
}
},"干扰线程");
main.start();
other.start();
}
}
输出结果如下:
我们看到结果中,在主线程 "比较并交换之前"
,干扰线程先是将 a
得值改成 2,然后又重新改回了 1,之后才执行主线程得 CAS操作!
2.2.2、如何解决 ABA 问题?
解决 ABA 问题最简单的方案就是给值加一个版本号,每次值变化,都会修改它的版本号,CAS 操作的时候都会去比对此版本号。
JAVA 中 ABA 的解决方法(AtomicStampedReference
),这种方式类似于 乐观锁,即:**通过当前版本号来控制 CAS 交换,如果当前版本号于期望版本号相等,才能进行交换,否则不可以交换,每执行一次交换当前版本号就 +1 **.
AtomicStampedReference
主要包含一个对象引用以及一个可以自动更新的整数 stamped 版本号
的 Pair
对象来解决 ABA 问题。
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;
AtomicStampedReference
中的 conpareAndSet()
方法:
/**
* Atomically sets the value of both the reference and stamp
* to the given update values if the
* current reference is {@code ==} to the expected reference
* and the current stamp is equal to the expected stamp.
*
* @param expectedReference the expected value of the reference 期望引用
* @param newReference the new value for the reference 新值引用
* @param expectedStamp the expected value of the stamp 期望引用得版本号
* @param newStamp the new value for the stamp 新值引用的版本号
* @return {@code true} if successful
*/
public boolean compareAndSet(V expectedReference,
V newReference,
int expectedStamp,
int newStamp) {
Pair<V> current = pair; // 引用的对象和版本号都封装在Pair类中
return
expectedReference == current.reference && // 期望引用与当前引用一致
expectedStamp == current.stamp && // 期望版本与当前版本一致
((newReference == current.reference && //
newStamp == current.stamp)
||
casPair(current, Pair.of(newReference, newStamp)));
}
private boolean casPair(Pair<V> cmp, Pair<V> val) {
return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}
使用 AtomicStampedReference
解决 ABA 问题:
/**
* @author wcc
* @date 2022/1/6 15:58
*/
public class CasABADemo02 {
public static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1),1);
public static void main(String[] args) {
Thread main = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("操作线程:"+Thread.currentThread().getName()+",[increment],引用值="+a.getReference()
+",版本号="+a.getStamp());
try {
Integer expectReference = a.getReference(); // 期望引用值
Integer newReference = expectReference + 1; // 新引用值
Integer expectStamp = a.getStamp(); // 期望版本号
Integer newStamp = a.getStamp(); // 新版本号
Thread.sleep(1000); // 主线程休眠1秒钟,让出CPU
boolean isCASSuccess = a.compareAndSet(expectReference, newReference, expectStamp, newStamp);
System.out.println("操作线程:"+Thread.currentThread().getName()+",CAS 操作:"+isCASSuccess);
System.out.println("操作结束:"+Thread.currentThread().getName()+",引用值="+a.getReference()
+",版本号="+a.getStamp());
}catch (Exception e){
e.printStackTrace();
}
}
},"主线程");
Thread other = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(20); // 确保main主线程优先执行
a.compareAndSet(a.getReference(), (a.getReference() + 1), a.getStamp(), (a.getStamp() + 1));
System.out.println("操作线程:"+Thread.currentThread().getName()+",[increment],引用值="+a.getReference()
+",版本号="+a.getStamp());
a.compareAndSet(a.getReference(), (a.getReference() - 1), a.getStamp(), (a.getStamp() + 1)); // a-1 a=1
System.out.println("操作线程:"+Thread.currentThread().getName()+",[increment],引用值="+a.getReference()
+",版本号="+a.getStamp());
}catch (Exception e){
e.printStackTrace();
}
}
},"干扰线程");
main.start();
other.start();
}
}
运行结果如下图所示:
这时就解决了 ABA 问题,如果主线程执行 CAS 操作前,出现狸猫 ABA 的情况,那么这个时候就不能进行比较并交换。