CAS操作(原子操作,底层使用处理器的CAS指令),内部通过乐观锁(旧值和新值比较或版本号比较)实现,
缺点:
ABA问题:值改成其他值后又改回来了,从而不知道是否改过(只控制结果,不能够控制过程)。解决方案添加版本号(默认旧值和新值进行比较),JDK 提供AtomicMarkableReference,AtomicStampedReference。
AtomicMarkableReference<V> ,可以控制ABA问题,保证是否修改过
AtomicStampedReference<V> 带时间版本戳的原子操作类。解决ABA问题,保证到修改了几次。
CPU开销问题:JDK执行器对于一个CAS指令内部是个死循环,最后更新成功则退出。
只能保证管理一个共享变量:不能控制多个变量。解决方案 多个变量封装到一个类中,使用AtomicReference。
- 1、单值操作 AtomicInteger AtomicBoolean AtomicLong
public static void main(String[] args) {
AtomicInteger atomicInteger=new AtomicInteger(3);
int andIncrement = atomicInteger.getAndIncrement();
int i = atomicInteger.incrementAndGet();
//加指定值
int i1 = atomicInteger.addAndGet(3);
//比较期望值,是则更新成功
boolean b = atomicInteger.compareAndSet(3, 5);
System.out.println("andIncrement = " + andIncrement+",i="+i+",i1="+i1+",b="+b+",atomicInteger="+atomicInteger);
//andIncrement = 3,i=5,i1=8,b=false,atomicInteger=8
}
- 2、数组操作 AtomicIntegerArray,AtomicLongArray,AtomicDoubleArray
Atomic中的数组和外面数组不是一个对象;
对数组的操作只能是修改值,不能够向数组中添加新值(索引超出异常);
public static void main(String[] args) throws InterruptedException {
int[] array=new int[]{1,2,3};
//外面的array和内部array不是同一个,是通过克隆的
AtomicIntegerArray atomicIntegerArray=new AtomicIntegerArray(array);
atomicIntegerArray.incrementAndGet(0);
atomicIntegerArray.addAndGet(2,5);
atomicIntegerArray.set(2,4);
System.out.println(atomicIntegerArray);
//[2, 2, 4]
}
- 3、AtomicReference 引用类型CAS使用,AtomicStampedReference 版本号控制和AtomicMarkableReference 标志控制
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicReference;
/**
* @ClassName ReferenceTest
* @Description 多个变量需要同时Atomic控制时,封装到一个对象类中 AtomicReference解决。一个对象更新成另一个对象
**/
public class ReferenceTest {
public static void main(String[] args) throws InterruptedException {
MiddleStatus status=new MiddleStatus(10,5);
AtomicReference<MiddleStatus> ato=new AtomicReference<>(status);
MiddleStatus expect=new MiddleStatus(12,6);
MiddleStatus newStatus=new MiddleStatus(20,10);
//保证原子操作,更新之前会比较 expect
ato.compareAndSet(expect,newStatus);
System.out.println("status = " + ato.get()); //更新失败,MiddleStatus{esfCount=10, zfCount=5}
ato.compareAndSet(status,newStatus);
System.out.println("status = " + ato.get());//更新成功,MiddleStatus{esfCount=20, zfCount=10}
}
private static class MiddleStatus{
private int esfCount;
private int zfCount;
public MiddleStatus(int esf,int zf){
this.esfCount=esf;
this.zfCount=zf;
}
@Override
public String toString() {
return "MiddleStatus{" +
"esfCount=" + esfCount +
", zfCount=" + zfCount +
'}';
}
}
}
import java.util.concurrent.atomic.AtomicMarkableReference;
import java.util.concurrent.atomic.AtomicStampedReference;
/**
* @ClassName StampTest
* @Description 通过时间戳控制原子操作,保证是否有修改,并制定修改了多少次
**/
public class StampTest {
private static class StampStatus{
public int sCount;
public StampStatus(int c){
this.sCount=c;
}
}
public static void main(String[] args) {
StampStatus s1=new StampStatus(2);
//通过Val和初始时间戳创建StampReference
int initialStap=2;
//AtomicStampedReference 可通过Stamp知道已经修改几次
AtomicStampedReference<StampStatus> ato=new AtomicStampedReference<>(s1,initialStap);
ato.compareAndSet(new StampStatus(3),new StampStatus(6),3,ato.getStamp()+1);
System.out.println(ato.getReference().sCount);//期望值和期望引用不正确,更新失败
//AtomicMarkableReference 可通过Mark知道是否更新过
AtomicMarkableReference<StampStatus> ato2=new AtomicMarkableReference<>(s1,false);
ato2.compareAndSet(new StampStatus(3),new StampStatus(6),false,true);
System.out.println(ato2.isMarked());
System.out.println(ato2.getReference().sCount);//期望标志和期望引用不对,修改失败
}
}