JAVA CAS原理以及应用atomic

• 官方说法：

提到CAS，就会想到悲观锁，乐观锁。 CAS是乐观锁。

CAS,compare and swap的缩写，中文翻译成比较并交换。

独占锁是一种悲观锁，synchronized就是一种独占锁，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁用到的机制就是CAS，Compare and Swap。

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该 位置的值。（在 CAS 的一些特殊情况下将仅返回 CAS 是否成功，而不提取当前 值。）CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。

• 个人理解

提到CAS，就会想到悲观锁，乐观锁。 CAS是乐观锁。

java 中读取数据并不是从物理内存（主内存）直接读入， 是从缓存中直接读入，再隔一段时间将缓存写入物理内存， 这样就会造成脏数据， CAS原理就是： 在使用的时候从物理内存中取出数据， 操作完再写入的时候，进行比较， 如果物理内存中的数据和之前取出时的数据一致或者说相同， 那就直接更新物理内存， 如果不一致， 那就重新取出， 再重新进行操作， 然后再重新写入，一直重复， 知道成功为止。

• Java中应用

Java包中Unsafe就是CAS的核心， java.util.concurrent.atomic包就是使用Unsafe CAS技术来实现的无锁。也就是平时说的atomic包下的类都是原子性的（原子性是通过CAS指令来实现的，由处理器保证）

例如： AtomicInteger 是线程安全的原因就是他使用volatile来保证可见性和有序性， 再使用CAS, UnSafe保证原子性。

private volatile int value;

//此处省略一万字代码

/**
 * Atomically sets to the given value and returns the old value.
 *
 * @param newValue the new value
 * @return the previous value
 */
public final int getAndSet(int newValue) {
    for (;;) {
        int current = get();
        if (compareAndSet(current, newValue))
            return current;
    }
}


/**
 * Atomically sets the value to the given updated value
 * if the current value {@code ==} the expected value.
 *
 * @param expect the expected value
 * @param update the new value
 * @return true if successful. False return indicates that
 * the actual value was not equal to the expected value.
 */
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    if(var0.getClassLoader() != null) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}