单例模式
深入理解CAS
package com.bjw.CAS;
import com.bjw.pc.A;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//期望、更新
//public final boolean compareAndSet(int expect, int update)
//如果我希望的值达到了,就更新否则就不更新,CAS 是CPU的并发原语
atomicInteger.compareAndSet(2020, 2021);
System.out.println(atomicInteger.get());
}
}
unsafe
CAS:比较当前工作内存中的值和主内存的值,如果这个值是期望的,那么则执行操作!如果不是就一直循环!
缺点
1、循环会耗时
2、一次性只能保证一个共享变量的原子性
CAS:ABA问题(狸猫换太子)
原子引用
首先先来了解这是干什么的,是为了解决ABA问题,ABA问题又是什么问题呢?看下面解释。
ABA问题用俗话来说,也就是狸猫换太子的问题,在多个线程运行下,上一个线程执行完将值返回给主存的时候,被另外一个线程更改回了原先的数据,导致下一个线程不知道线程被更改的问题!
解决ABA问题,引入原子引用!对应的思想就是乐观锁
package com.liu.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo01 {
//cas:compareAndSet:比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2022); //底层用的cas
//public final boolean compareAndSet(int expect, int update)
//如果期望的值达到了就更新,否则不更新,CAS是CPU的并发原语!
//对于写的sql:利用乐观锁解决问题:要知道谁动了线程!
//=======捣乱的线程=========
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2023, 2022));
System.out.println(atomicInteger.get());
//=======捣乱的线程=========
System.out.println(atomicInteger.compareAndSet(2022, 6666));
System.out.println(atomicInteger.get());
}
}
利用带版本号的原子引用解决ABA问题:知道谁动了线程,修改了数据,AtomicStampedReference() 带时间戳的,对应的思想是乐观锁
避坑:
Integer使用了对象缓存机制,默认范围是-128-127,推荐使用静态工厂方法valueOf获取对象实例,而不是new,因为valueOf使用缓存,而new一定会创建新的对象分配新的内存空间,超过这个区间的所有数据都会在堆上产生,不会复用对象
package com.liu.cas;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo02 {
public static void main(String[] args) {
//注意:如果泛型是包装类,注意对象的引用问题,因为是对象缓存机制,超过一定访问再new的话会新分配空间地址
//正常在业务操作,这里引用的都是一个对象
AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);
new Thread(()->{
int stamp = atomicInteger.getStamp();//获得版本号
System.out.println("a1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//下面这一段代码跟乐观锁里面的version+1版本号操作一样
System.out.println(atomicInteger.compareAndSet(1, 2,
atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("a2=>"+atomicInteger.getStamp());
System.out.println(atomicInteger.compareAndSet(2, 1,
atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
System.out.println("a3=>"+atomicInteger.getStamp());
},"a").start();
//与乐观锁的原理相同,由于中间修改过了线程,导致正常的线程不能修改,返回false
new Thread(()->{
int stamp = atomicInteger.getStamp();//版本号获取
System.out.println("b1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(1, 6, stamp, stamp + 1));
System.out.println("b2=>"+atomicInteger.getStamp());
},"b").start();
}
}