Java并发编程-CAS

CAS（Compare-and-Swap）：比较替换。这个思想非常的重要，在Java并发编程中多处用到，包括轻量级锁也用到了CAS的思想。所以我觉得有必要单独学习一下。
 

class CAS{

    Object value;

    Object getValue(){
        return this.value;
    }

    void setValue(Object obj){
        this.value=obj;
    }

    boolean compareAndSwap(Object localValue,object newValue){
        if(this.getValue().equal(localValue)){
            setValue(newValue);
            return true;
        }else{
            return false;
        }
    }

}

CAS的思想就是上面这段代码！循环CAS可以很高效的解决多线程中原子操作的问题。但是CAS也有3个比较大的问题：

1）ABA问题。因为CAS需要在操作值的时候，检查之有没有变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它没有发生变化，但是实际上却发生了变化。ABA问题的解决思路是使用版本号。在变量前面追加版本号，每次变量更新的时候版本号增1。那么A—B—A就变成了1A—2B—3A。JDK1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

2）循环时间长开销大。自旋CAS如果时间长不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器的pause指令，那么效率一定会有所提升。pause指令有俩作用：第一，它可以延迟流水线指令，使CPU不会消耗过多的执行资源，延迟的时间取决于具体的实现版本，在一些处理器上延迟时间是零；第二，它可以避免在退出循环的时候因为内存顺序冲突而引起CPU流水线被清空，从而提高CPU效率。

3）只能保证一个共享变量的操作。当对一个共享变量执行操作时，可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以使用锁。从JDK1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

public class AtomicReferenceTest {

    static class User {
        private String name;
        private int old;

        public User(String name, int old) {
            this.name = name;
            this.old = old;
        }

        public String getName() {
            return name;
        }

        public int getOld() {
            return old;
        }
    }

    public static AtomicReference<User> atomicUserRef = new AtomicReference<User>();

    public static void main(String[] args) {
        User user = new User("oldValue", 1);
        atomicUserRef.set(user);
        User updateUser = new User("newValue", 2);
        atomicUserRef.compareAndSet(user, updateUser);
        System.out.println(atomicUserRef.get().getName());
        System.out.println(atomicUserRef.get().getOld());
    }

}

以上代码引自并发编程网。