AtomicInteger的getAndIncrement 相当于i++为什么能够保证原子性

研究这个方法的底层源码

AtomicInteger用CAS但不用synchronized

用synchronized一致性得到了保障但并发性下降了很多
我们用CAS是用do…while反复进行判断既保证了一致性 又没有降低并发性。
CAS---->compare And Swap，他是一条CPU并发原语。他在执行过程中不允许中途被打断，也就是说CAS是一条cpu上的原子指令，不会造成数据的不一致的情况。
CAS缺点:
1.高并发环境下 加入一直while循环判断不成功那么cup开销极大。
2.只能保证一个共享变量的原子性问题不能保证一段代码。
3.可能引发ABA问题
四个字概括狸猫换太子。
假如说t1与t2同时对数据A进行操作，t1把数据A变成了B更新到了主内存当中去，但是这时t2并不知道，t1有把B更新成了A，然后这时t2去主内存中看，还是A没毛病，把主内存的A改成了他自己的数据。这就是ABA问题

底层汇编语言

ABA问题的解决方案:

在原子类中有一个AtomicStampedReference类可以解决带有版本号解决这个问题。

public class ABADemo {
    /**
     * 这里的Integer不能大于127若大于127则不会出现ABA情况，也就是没有CAS
     * true	128
     * false	128
     */
    private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

    private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);

    public static void main(String[] args) {

        System.out.println("===以下是ABA问题的产生===");

        new Thread(() ->{
            System.out.println(atomicReference.compareAndSet(100, 127)+"\t"+atomicReference.get());

            System.out.println(atomicReference.compareAndSet(127, 100)+"\t"+atomicReference.get());

        },"t1").start();


        new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019)+"\t"+atomicReference.get());

        },"t2").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("===以下是ABA问题的解决===");

        new Thread(() ->{
            System.out.println(Thread.currentThread().getName()+"\t第一次版本号："+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(100, 127,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1)+"\t"+atomicStampedReference.getReference());

            System.out.println(Thread.currentThread().getName()+"\t第二次版本号："+atomicStampedReference.getStamp());
            System.out.println(atomicStampedReference.compareAndSet(127, 100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1)+"\t"+atomicStampedReference.getReference());

            System.out.println(Thread.currentThread().getName()+"\t第三次版本号："+atomicStampedReference.getStamp());

        },"t3").start();


        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();

            System.out.println(Thread.currentThread().getName()+"\t第一次版本号："+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicStampedReference.compareAndSet(100, 2019,stamp,stamp+1)+"\t"+atomicStampedReference.getReference());
            System.out.println(Thread.currentThread().getName()+"\t最新的版本号："+atomicStampedReference.getStamp());



        },"t4").start();


    }
}