JDK 中CAS(原子)操作工具类 AtomicInteger AtomicIntegerArray AtomicReference等等

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);//期望标志和期望引用不对，修改失败
    }
}