本文内容：

Atomic原子类
CAS(无锁优化，乐观锁)
ABA问题
Unsafe

对某些常见操作，加锁的情况有很多，所以Java提供了一些类来实现这种操作，这些类内部自动带了锁，但这锁不是synchronized实现，而是CAS的操作来实现的。

Atomic原子类

以AtomicXXX开头的都是用CAS操作来保证线程安全的类。

在开发工作中经常有多个线程共同访问一个值，改变一个值的场景，这时就可以使用原子类如AtomicInteger。这里面包含了int类型，这个int类型的自增count++是线程安全的，取值也是线程安全的。

如下，不用再对m()加synchronized，输出一定为10万

public class AtomicInteger_01 {

    AtomicInteger count = new AtomicInteger(0);

    void m() {
        for (int i=0; i<10000; i++) {
            count.incrementAndGet(); // 自增 count++
        }
    }

    public static void main(String[] args) {
        AtomicInteger_01 instance = new AtomicInteger_01();
        List<Thread> threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread(instance::m, "thread-"+i));
        }

        threads.forEach( thread -> thread.start());

        threads.forEach( thread -> {
            try {
                thread.join(); // 自增线程执行完后才执行主线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(instance.count);
    }
}

CAS原理

原子类内部都使用了CAS，上面代码的自增方法

public final int incrementAndGet() {
    return U.getAndAddInt(this, VALUE, 1) + 1;
}

incrementAndGet()方法调用了getAndAddInt 这是一个CompareAndSetInt操作

@HotSpotIntrinsicCandidate
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

也就是说AtomicInteger它的内部是调用了Unsafe这个类里面的方法CompareAndSetInt（CAS），字面意思是比较且设定。要改变某个值，想要线程安全可以加锁synchronized，现在可以用另一种操作来代替加锁操作，这就是CAS操作。

CAS执行原理

为了说明问题将CAS操作想象成一个方法 cas(V, Expected, NewValue)，V是需要被修改的那个值，Expected是期望当前这个V是几，NewValue是要设置的新值。

// 伪代码
cas(V, Expected, NewValue){
    if (V == Expected) {
        V = NewValue;
    } else {
        try again or fail
    }
}

比如要把1改为2。这时参数V=1，因为期望进行赋值操作时V没被别的线程修改所以Expected=1，NewValue=2。如果V == Expected，正常赋值；如果其它某个线程把V改为了2，V != Expected，这个线程会重新尝试，这时V=2，Expected=2......如此运行。这就是CAS操作，本质上是这么个运行过程。

简言之，Expected期望值和V实际值相等才会进行新值设定，V被其他线程改了后，当前线程会重试或失败，这就是CAS操作。

注意！
判断V==Expected后，赋值操作前不会再有别的线程进来改变V。CAS是CPU的原语支持，也就是说CAS操作是CPU指令级别上的支持，中间不能被打断。以上代码只是为了方便解释的伪代码。

ABA问题

CAS可以有效提升并发效率，但同时也会引入ABA问题。

• 什么是ABA问题？
  比如要把1变成2，A线程从内存中取出1，B线程也从内存中取出1并且将1改成2后又改回1，这时不会影响A线程进行CAS操作，这就是ABA问题。

所以JAVA中提供了AtomicStampedReference/AtomicMarkableReference来处理会发生ABA问题的场景，主要是在对象中额外再增加一个标记来标识对象是否有过变更。任何一个值的修改都使版本号加1，检查时连版本号一起检查。

如果是基础类型：无所谓，不影响结果值。
如果是引用类型：就像你的女朋友跟你分手后又复合，中间经历了别的男人。

Unsafe（了解即可）

Unsafe可以看作C或C++中的指针，它可以:

• 直接操作内存
  allocateMemory，putXX，freeMemory，pageSize
• 直接生成类实例
  allocateInstance
• 直接操作类或实例变量
  objectFieldOffset
  getInt
  getObject
• CAS相关操作
  weakCompareAndSetXXX(Object Int Long ...)

这个类不能被直接使用，需要利用反射使用，不能直接使用是和ClassLoader有关。所有的Atomic类操作内部都是使用CAS，而CAS就是在Unsafe类里完成的。