CAS笔记

CAS(Compare And Swap)

独占锁是一种悲观锁，而 synchronized 就是一种独占锁，synchronized 会导致其它所有未持有锁的线程阻塞，而等待持有锁的线程释放锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。而乐观锁用到的机制就是CAS。在java中可以通过锁和循环CAS的方式来实现原子操作。java.util.concurrent.atomic包相关类就是CAS的实现。

CAS机制当中使用了3个基本操作数：内存地址V(value，volatile修饰的变量)，旧的预期值A(expected)，要修改的新值B(updated)。

更新一个变量的时候，只有当前变量的预期值cur和内存地址V中的实际值(value)相同时，才会将内存地址V对应的值(value)修改为B(updated)。

原子更新基本类型

原子更新基本类型主要包括3个类：

1. AtomicBoolean：原子更新布尔类型
2. AtomicInteger：原子更新整型
3. AtomicLong：原子更新长整型

• CAS机制实现自增(保证原子性)

/**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);//获取当前值，相当与上面提到的预期值A
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));  //比较当前值与实际值，var5+var4相当于updated

        return var5;  //返回swap后的值
}

getAndAddInt中的内容是：
1. 获取当前值var5通过getIntVolatile()。
2. while循环，如果当前值var5 等于 实际值value，则compareAndSwapInt返回true，将实际值更新后，并跳出循环。若不等于，则进入循环，尝试重新获取当前值，将当前值重新与实际值compare，这个重新尝试的过程被称为自旋。
3. 返回交换后的值。

从思想上来说，Synchronized属于悲观锁，悲观地认为程序中的并发情况严重，所以严防死守。CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去尝试更新。

package cn.itcast.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger ai = new AtomicInteger();
    private int i = 0;

    /** 使用CAS实现线程安全计数器 */
    private void safeCount() {
        for (;;) {
            int i = ai.get();
            // 如果实际值（执行到这一步时，从内存V中获取的value） == 预期值(上一步获取的当前值)，则以原子方式将该值设置为给定的更新值
            boolean suc = ai.compareAndSet(i, ++i);  //第一个参数：expected value；第二个参数：updated value
            if (suc) {
                break;
            }
        }
    }

    /** 非线程安全计数器 */
    private void count() {
        i++;
    }

    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> ts = new ArrayList<Thread>();
        // 添加1000个线程
        for (int j = 0; j < 1000; j++) {
            ts.add(new Thread(new Runnable() {
                public void run() {
                    // 执行1000次计算，预期结果应该是1000000
                    for (int i = 0; i < 1000; i++) {
                        cas.count();
                        cas.safeCount();
                    }
                }
            }));
        }
        //开始执行
        for (Thread t : ts) {
            t.start();
        }
        // 等待所有线程执行完成
        for (Thread t : ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /**
         * 非线程安全计数结果：999689
         * 线程安全计数结果：1000000
         */
        System.out.println("非线程安全计数结果："+ cas.i);
        System.out.println("线程安全计数结果："+ cas.ai.get());
    }
}

正是unsafe(提供硬件级别的原子操作)的compareAndSwapInt方法保证了Compare和Swap操作之间的原子性操作。(比较返回为true才进行替换，否则不执行任何操作(自旋))

原子更新引用

原子更新引用类型可以同时更新引用类型(AtomicReference原子类)，即原子更新引用类型。

原子更新数组

原子更新数组指的是通过原子的方式更新数组里的某个元素，主要有以下3个类

1. AtomicIntegerArray：原子更新整数数组里的元素
2. AtomicLongArray：原子更新长整数数组里的元素
3. AtomicReferenceArray：原子更新引用类型数组里的元素

CAS的缺点

1. 循环时间开销大：自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。
2. 只能保证一个共享变量的原子操作：当对一个共享变量执行操作时，可以使用循环CAS的方式来保证原子操作，但对于多个共享变量操作时，循环CAS就无法保证操作的原子性。这时候就可以用锁；或者一个取巧的方式，就是把多个共享变量合并成一个对象来操作。从java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。
3. ABA问题：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。 从Java1.5开始JDK的 atomic包里提供了一个类AtomicStampedReference 来解决ABA问题。这个类的 compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。(改用传统的互斥同步可能会比原子类更高效)