aba会导致问题_CAS导致的ABA问题及解决

最新推荐文章于 2023-10-20 17:40:45 发布

阿尔法老师

最新推荐文章于 2023-10-20 17:40:45 发布

阅读量619

点赞数

文章标签： aba会导致问题

本文链接：https://blog.csdn.net/weixin_29156679/article/details/112810164

版权

本文解析了CAS(CompareAndSwap)算法的工作原理、ABA问题以及解决方案，通过 AtomicInteger 类例演示了在多线程环境下的应用。重点讲解了如何通过版本号避免ABA问题，以及Java并发包中的原子类如何确保数据一致性。

摘要由CSDN通过智能技术生成

什么是CASCAS(Compare And Swap/Set)比较并交换，CAS算法的过程是这样：它包含3个参数CAS(V,E,N)。V表示要更新的变量(内存值)，E表示预期值(旧的)，N表示新值。当且仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS返回当前V的真实值。 CAS操作是抱着乐观的态度进行的(乐观锁)，它总是认为自己可以成功完成操作。当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。基于这样的原理，CAS操作即使没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。

JDK1.5的原子包：java.util.concurrent.atomic这个包里面提供了一组原子类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。相对于对于synchronized这种阻塞算法，CAS是非阻塞算法的一种常见实现。由于一般CPU切换时间比CPU指令集操作更加长，所以J.U.C在性能上有了很大的提升。如下代码：

// AtomicInteger类 157行

public final int getAndIncrement() {

return unsafe.getAndAddInt(this, valueOffset, 1);

}

// Unsafe 358行

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;

}

运行代码示例：

public class Demo8 {

// 主内存atomicInteger初始值为100

public static AtomicInteger atomicInteger = new AtomicInteger(100);

public static void main(String[] args) throws InterruptedException {

System.out.println("============== 演示 CAS =============");

// t1线程计划将值改为102，先休眠2s,再比较交换发现主物理内存的值已经变成了102 而自己期望值为100所以修改失败

new Thread(() -> {

try { TimeUnit.SECONDS.sleep(2);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("当前线程: "+Thread.currentThread().getName()+"比较交换结果："

+atomicInteger.compareAndSet(100, 102)+" 现在值为："+atomicInteger.get());

},"t1").start();

// t2线程计划将值改为2019，不休眠发现主物理内存的值已经变成了100 而自己期望值为100所以修改成功

new Thread(() -> {

System.out.println("当前线程: "+Thread.currentThread().getName()+"比较交换结果："

+atomicInteger.compareAndSet(100, 2019)+" 现在值为："+atomicInteger.get());

},"t2").start();

}

结果：

============== 演示 CAS =============

当前线程: t2比较交换结果：true 现在值为：2019

当前线程: t1比较交换结果：false 现在值为：2019

ABA问题

CAS会导致“ABA问题”。CAS算法实现一个重要前提需要取出内存中某时刻的数据，而在下时刻比较并替换，那么在这个时间差类会导致数据的变化。比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成了B，然后two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后one操作成功。尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。

解决方案

部分乐观锁的实现是通过版本号(version)的方式来解决ABA问题，乐观锁每次在执行数据的修改操作时，都会带上一个版本号，一旦版本号和数据的版本号一致就可以执行修改操作并对版本号执行+1操作，否则就执行失败。因为每次操作的版本号都会随之增加，所以不会出现ABA问题，因为版本号只会增加不会减少。

代码示例：

package com.interview.javabase.thread;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicStampedReference;

public class Demo8 {

// 主内存共享变量，初始值为100，版本号为1

private static AtomicStampedReference atomicStampedReference = new

AtomicStampedReference<>(100, 1);

public static void main(String[] args) throws InterruptedException {

System.out.println("============== 演示 CAS ABA问题=============");

// t1进行ABA操作

new Thread(() -> {

atomicInteger.compareAndSet(100,102);

atomicInteger.compareAndSet(102,100);

System.out.println(Thread.currentThread().getName()+" 最新值为："+atomicInteger.get());

},"t1").start();

// t2进行CAS操作

new Thread(() -> {

try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

boolean b = atomicInteger.compareAndSet(100, 2019);

System.out.println(Thread.currentThread().getName() +"是否修改成功"+b+" 最新值为："+atomicInteger.get());

},"t2").start();

try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

System.out.println("============== 解决 CAS ABA问题=============");

new Thread(() -> {

// 第一次拿到的版本号

int stamp = atomicStampedReference.getStamp();

System.out.println(Thread.currentThread().getName()+" 第1次版本号："+stamp+" 值为："+atomicStampedReference.getReference());

try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

atomicStampedReference.compareAndSet(100,102,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);

System.out.println(Thread.currentThread().getName()+" 第2次版本号："+atomicStampedReference.getStamp()+" 值为："+atomicStampedReference.getReference());

atomicStampedReference.compareAndSet(102,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);

System.out.println(Thread.currentThread().getName()+" 第3次版本号："+atomicStampedReference.getStamp()+" 值为："+atomicStampedReference.getReference());

},"t3").start();

new Thread(() -> {

// 第一次拿到的版本号

int stamp = atomicStampedReference.getStamp();

System.out.println(Thread.currentThread().getName()+" 第1次版本号："+stamp+" 值为："+atomicStampedReference.getReference());

// 休眠3s,确保t3执行完ABA操作

try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

// t2将时间戳改为了3,cas失败

boolean b = atomicStampedReference.compareAndSet(100, 209, stamp, stamp + 1);

System.out.println(Thread.currentThread().getName()+"是否修改成功"+b+" 当前最新版本号："+atomicStampedReference.getStamp()+" 最新值为："+atomicStampedReference.getReference());

},"t4").start();

}

结果:

============== 演示 CAS ABA问题=============

t1 最新值为：100

t2是否修改成功true 最新值为：2019

============== 解决 CAS ABA问题=============

t3 第1次版本号：1 值为：100

t4 第1次版本号：1 值为：100

t3 第2次版本号：2 值为：102

t3 第3次版本号：3 值为：100

t4是否修改成功false 当前最新版本号：3 最新值为：100