CAS(CompareAndSweep)工作方式
CAS是乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。
CAS 操作中包含三个操作数 —— 需要读写的内存位置(V)、进行比较的预期原值(A)和拟写入的新值(B)。如果内存位置V的值与预期原值A相匹配,那么处理器会自动将该位置值更新为新值B。否则处理器不做任何操作。无论哪种情况,它都会在 CAS 指令之前返回该位置的值。(在 CAS 的一些特殊情况下将仅返回 CAS 是否成功,而不提取当前值。)CAS 有效地说明了“ 我认为位置 V 应该包含值 A;如果包含该值,则将 B 放到这个位置;否则,不要更改该位置,只告诉我这个位置现在的值即可。 ”这其实和乐观锁的冲突检查+数据更新的原理是一样的。
强调一下,乐观锁是一种思想。CAS是这种思想的一种实现方式。
过程图解如下:
- 内存地址V当中,存储着值为10的变量
- 此时线程1想要把变量的值增加1,对线程1来说,旧的预期值A=10,要修改的新值B=11
- 在线程1要提交更新之前,另一个线程2抢先一步,把内存地址V中的变量值率先更新成了11。
- 线程1开始提交更新,首先进行A和地址V的实际值比较(Compare),发现A不等于V的实际值,提交失败。
- 线程1重新获取内存地址V的当前值,并重新计算想要修改的新值。此时对线程1来说,A=11,B=12。这个重新尝试的过程被称为自旋。
- 这一次比较幸运,没有其他线程改变地址V的值。线程1进行Compare,发现A和地址V的实际值是相等的。
- 线程1进行SWAP,把地址V的值替换为B,也就是12。
CAS的特点
结合CAS和volatile可以实现无锁并发,适用于线程数少,多核CPU场景下
- CAS是基于乐观锁的思想:最乐观的估计,不怕别的线程来修改共享变量,就算改了也没关系,我再重试呗
- synchronized是基于悲观锁的思想:最悲观的估计,得防着其他线程来修改共享变量,我上了锁你们都别想改,我改完了解开锁,你们才有机会
- CAS体现的是无锁并发,无阻塞并发
- 因为没有使用synchronized,所以线程不会陷入阻塞,这是效率提升的因素之一
- 但如果竞争激烈,重试必然会频繁发生,反而效率会受影响
原子整数
JUC并发包提供了
- AtomicBoolean
- AtomicInteger
- AtomicLong
以AtomicInteger为例
public static void main(String[] args){
AtomicInteger i = new AtomicInteger(3);
System.out.println(i.incrementAndGet()); // ++i
System.out.println(i.getAndIncrement()); // i++
System.out.println(i.addAndGet(12)); //先加后取值
System.out.println(i.getAndAdd(12)); //先取值后加
System.out.println(i.get());
// 读取到 设置值
System.out.println(i.updateAndGet(x -> x * 10));
}
原子引用ABA问题
public class getClassTest {
static AtomicReference<String> ref = new AtomicReference<>("A");
public static void main(String[] args) {
System.out.println("main start...");
String prev = ref.get();
other();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": A -> C " + ref.compareAndSet("A", "C"));
}
public static void other() {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + ": A -> B " + ref.compareAndSet("A", "B"));
}, "t1").start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + ": B -> A " + ref.compareAndSet("B", "A"));
}, "t2").start();
}
}
主线程仅能判断出共享变量的值与最初值A是否相同,不能感知到这种从A改为B又改回A的情况,如果主线程希望:
只要有其他线程 动过了 共享变量,那么自己的cas就算失败,这时,仅比较值是不够的,需要再加一个版本号
public class getClassTest {
static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args) {
System.out.println("main start...");
//获取值A
String prev = ref.getReference();
//获取版本号
int stamp = ref.getStamp();
System.out.println(Thread.currentThread().getName() + " stamp : " + stamp);
other();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +" stamp : "+ stamp);
System.out.println(Thread.currentThread().getName() + ": A -> C " + ref.compareAndSet(prev, "C", stamp, stamp + 1));
}
public static void other() {
new Thread(() -> {
int stamp = ref.getStamp();
System.out.println(Thread.currentThread().getName() + " stamp : " + stamp);
System.out.println(Thread.currentThread().getName() + ": A -> B " + ref.compareAndSet(ref.getReference(), "B", stamp, stamp + 1));
}, "t1").start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
int stamp = ref.getStamp();
System.out.println(Thread.currentThread().getName() + " stamp : " + stamp);
System.out.println(Thread.currentThread().getName() + ": B -> A " + ref.compareAndSet(ref.getReference(), "A", stamp, stamp + 1));
}, "t2").start();
}
}
© 著作权归作者所有
发表评论