1、理解CAS
什么是CAS?
大厂你必须要深入研究底层!有所突破!修内功,操作系统,计算机网络原理
package com.jialidun.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet:比较并交换!
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//int expect期望、 int update更新
//public final boolean compareAndSet(int expect, int update) {
//如果我期望的值达到了,name就更新,否则就不更新,CAS是CPU的并发原语!
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
atomicInteger.getAndIncrement();//++
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
}
}
Unsafe类
CAS:比较当前工作内存中的值和主内存的值,如果这个值是期望的,那么则执行操作!如果不是就一直循环!
CAS:三个值,期望值,比较值,更新的值
缺点:
1、因为底层实现自旋锁,循环会耗时
2、一次性只能保证一个共享变量的原子性
3、ABA问题
CAS:ABA问题(狸猫换太子)
package com.jialidun.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet:比较并交换!
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//int expect期望、 int update更新
//public final boolean compareAndSet(int expect, int update) {
//如果我期望的值达到了,name就更新,否则就不更新,CAS是CPU的并发原语!
//================捣乱的线程=======================
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, 6666));
System.out.println(atomicInteger.get());
}
}
2、原子引用
解决ABA问题,引入原子引用!对应的思想:乐观锁!
带版本号的原子操作!
大概解释一下乐观锁:乐观锁是一种锁类型,CAS是乐观锁的一种具体实现方法,乐观锁大概也就是加个版本控制,如果事务改变那么版本也会改变!
package com.jialidun.cas;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo {
//CAS compareAndSet:比较并交换!
// AtomicStampedReference 注意,如果泛型是一个包装类,注意对象的引入问题
public static void main(String[] args) {
//正常在业务操作,这里面比较的都是一个个对象
AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
new Thread(()->{
int stamp = atomicStampedReference.getStamp();
System.out.println("a1=>"+stamp);
atomicStampedReference.compareAndSet(1,2,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
System.out.println("a2=>"+atomicStampedReference.getStamp());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(), atomicStampedReference.getStamp()+1);
System.out.println("a3=>"+atomicStampedReference.getStamp());
},"a").start();
//乐观锁的原理相同!
new Thread(()->{
int stamp = atomicStampedReference.getStamp();
System.out.println("b1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(1,6,stamp,stamp+1);
System.out.println("b2=>"+atomicStampedReference.getStamp());
},"b").start();
}
}
注意:
Integer使用了对象缓存机制,默认范围是-128~127,推荐使用静态工厂方法valueOf获取对象实例,而不是new,因为valueOf使用缓存,而new一定会创建新的对象分配新的内存空间;