标签：中比 执行流程 equal stat 其他 cin 线程优先级 catch 成功
一 概念
在计算机中比较和交换（Conmpare And Swap 即 CAS）是用于实现多线程同步的原子指令，当多个线程对某个资源进行CAS操作,只能有1个线程成功，其他线程并不会阻塞而是返回失败信号。
二 基本原理
每个CAS包含3个运算符
1 内存地址 V
2 旧的预期值A
3 新增B
基本思路，如果V地址上的值和传入的旧的期望值A相等，就给地址赋个新值B，否则不做任何处理
if(V.value.equals(A))
{
V.value = B;
return true;
}else
{
return false;
}
常用 原子操作类型
基本类型 AtomicInteger,AtomicLong,AtomicBoolean;
数组类型 AtomicIntegerArray,AtomicLongArray,AtomicReferenceArray;
引用类型 AtomicReference，AtomicMarkableReference,AtomicStampedReference
三 常见用法和ABA问题
3.1 常见用法
原子操作基本类型（Integer）
AtomicInteger atomicInteger = new AtomicInteger(10);
//基本类型原子操作测试
public void atomicIntegerTest()
{
//自增1 并返回新值
System.out.println("自增 并返回新值="+atomicInteger.incrementAndGet());
//返回旧值，再加1
System.out.println("返回 ="+ atomicInteger.getAndIncrement()+" 并自增");
}
结果
自增 并返回新值=11
返回=11 并自增
用途 比如可以用于多线程的计数等，
//原子操作类型数组
int [] arr = new int[]{1,2,3,4,5,6,7,8};
private AtomicIntegerArray atomicArray = new AtomicIntegerArray(arr);
@Test
public void test()
{
//获取索引为0的值，并修改索引0里的值为3
System.out.println(atomicArray.getAndSet(0,3));
System.out.println("原数组索引0的值="+arr[0]);
System.out.println("原子类型数组里索引0的值="+atomicArray.get(0));
}
结果
1
原数组索引0的值=1
原子类型数组里索引0的值 = 3；
3.2 ABA问题
原来V地址上值为A
1. 时刻1 线程1 执行读取操作，获取原值A，然后线程被切换走了
2. 时刻2 线程2 更新了V上的值为B
3. 时刻3 线程2 更新了V上的值为A
4. 时刻4 线程1恢复运行，将比较值（compareValue）与原值（oldValue）进行比较，发现两个值相等（都是A）。
然后用新值（newValue）B 写入内存中，完成 CAS 操作
我们可以发现，其实V值，在线程1修改之前，已经被修改过2次了（改为B，又改回A）
但线程1并不知道原值被修改，所以继续执行流程。
处理ABA问题
通常是对每一次CAS操作设置版本戳，目前java.util.concurrent.atomic包下提供2种原子类
AtomicMarkableReference AtomicStampedReference
版本戳是 boolean 类型 版本戳是number类型
只关心数据是否被动过 关心数据被动过几次
看具体示例
public class AtomicStampedRefernceTest {
//带版本戳的原子操作
private static AtomicStampedReference<String> atomicStampedReference = new AtomicStampedReference<>("作者", 1);
//旧的版本戳
final int oldstamp = atomicStampedReference.getStamp();
//旧值
final String oldValue = atomicStampedReference.getReference();
@Test
public void mainTest() {
Thread right = new Thread(new rightThread());
//正确版本号线程
//错误版本号线程
Thread error = new Thread(new errorThread());
try {
right.start();
right.join();
error.start();
error.join();
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
//正确使用了版本号进行了CAS的线程
public class rightThread implements Runnable {
@Override
public void run() {
String value = atomicStampedReference.getReference();
int stamp = atomicStampedReference.getStamp();
Thread.currentThread().setName("正确使用了版本号线程");
System.out.println(Thread.currentThread().getName() + "：值=" + value + "，版本戳=" + stamp + " CAS结果=" +
atomicStampedReference.compareAndSet(value, value + "-帅哥", stamp, stamp + 1));
}
}
//错误使用了版本号进行了CAS的线程
public class errorThread implements Runnable {
@Override
public void run() {
String value = atomicStampedReference.getReference();
int stamp = atomicStampedReference.getStamp();
Thread.currentThread().setName("错误使用了版本号线程");
System.out.println(Thread.currentThread().getName() + "：值=" + value + "，版本戳=" + stamp + " CAS结果=" +
atomicStampedReference.compareAndSet(value, value + "-老者", oldstamp, oldstamp + 1));
}
}
}
输出结果
正确使用了版本号线程：值=作者，版本戳=1 CAS结果=true
错误使用了版本号线程：值=作者-帅哥，版本戳=2 CAS结果=false
总结：
CAS和synchronized有什么区别？
synchronized是java的内置锁，目的是用于锁住某块资源，确保这块资源只能被一个线程访问（即确保资源的原子性），是悲观锁。
CAS是计算机指令级别的一个原子操作
使用synchronized 有什么不方便的地方或者弊端？
1 synchronized 是基于阻塞机制，如果某个线程拿不到锁会阻塞在那里，当被阻塞的线程优先级很高时，我们无法中断
2 拿到锁的线程一直不释放怎么办
3 大量竞争锁，会出现死锁或活锁，而且会消耗CPU,以及其他一些安全问题
使用CAS的弊端
为了确保CAS操作成功，你要死循环调用，直到成功为止，造成CPU开销问题
什么情况下用CAS?
当觉得用锁不方便，或者太笨重时，可以考虑用CAS
标签：中比 执行流程 equal stat 其他 cin 线程优先级 catch 成功
原文地址：https://www.cnblogs.com/hup666/p/11871403.html
