关于java:CAS

CAS(compare and swap)，即：比拟而后替换，运行程序如图：

三个运算符：一个内存地址 V，一个期望值 A，一个新值 B。
基本思路：如果地址 V 上的值和期望值 A 相等，返回 true，并给地址 V 赋上新值 B，如果不是，返回 false，不做任何操作。
循环 (死循环，或者叫自旋) 里一直的进行 CAS 操作。

古代处理器都反对 CAS 的指令，循环这个指令，直到胜利为止，蓝色局部是个原子操作，这个原子操作是计算机为咱们保障的，毋庸放心平安问题。

ABA 问题。

ABA 问题就是假如某个内存地址上有一个数值 A，但一个线程过去后把它变成了 B，而后又变回了 A，另一个线程过去后，发现内存地址上的值和冀望的值一样，故 CAS 胜利了，其实，内存地址上的值产生了变动，这种问题能够用加版本号的形式来解决。

零碎开销问题。

当一个 CAS 操作永远不胜利，它就会始终自旋，零碎开销微小，遇到这种状况，咱们只能应用 syn 锁或者其余锁的形式来代替 CAS 操作了。

只能保障一个共享变量的原子操作。

就是只可能保障一个共享变量，如果想保障多个变量的话，能够将这些变量放入一个援用变量中，atomic为咱们提供了操纵援用变量的类，叫AtomicReference

根本类型类：AtomicBoolean，AtomicInteger，AtomicLong
数组类：AtomicIntegerArray，AtomicLongArray
援用类型：AtomicReference，AtomicMarkableReference，AtomicStampedReference
原子更新字段类：AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater

public class Test {static AtomicInteger ai = new AtomicInteger(10);

    public static void main(String[] args) {

        // 相似 "i++"
        System.out.println(ai.getAndIncrement());
        // 相似 "++i"
        System.out.println(ai.incrementAndGet());
        System.out.println(ai.get());
        
        // ---------- 减少指定数值 --------------
        //System.out.println(ai.addAndGet(10));
        //System.out.println(ai.getAndAdd(10));

    }

}

打印后果：

10
12
12

public class Test {static AtomicReference<User> atomicReference = new AtomicReference();

    public static void main(String[] args) {User user = new User("70KG", 18); // 要批改的实例
        // 用之包装一下实体类对象
        atomicReference.set(user);

        // 新对象
        User newUser = new User("80KG", 20);

        // CAS 操作
        boolean flag = atomicReference.compareAndSet(user, newUser); // 要变动的实例
        System.out.println(flag);

        // 打印包装类中的对象
        System.out.println(atomicReference.get().getName());
        System.out.println(atomicReference.get().getAge());

        System.out.println("========================");

        // 打印原对象
        System.out.println(user.getName());
        System.out.println(user.getAge());
    }


    // 定义一个实体类
    static class User {

        private String name;

        private int age;

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

        public String getName() {return name;}

        public int getAge() {return age;}
    }

}

运行后果：

true
80KG
20
========================
70KG
18

剖析：
通过 compareAndSet 办法进行 CAS 操作，可见被包装过的 user 对象本值是不会发生变化的，扭转的只是包装的 user 对象，他们两个在被包装的时候就曾经不同了。

public class Test01 {

    // 申明援用值为 0
    static AtomicReference<Integer> atomicReference = new AtomicReference(0);

    public static void main(String[] args) throws InterruptedException {

        // 援用
        final Integer reference = atomicReference.get();
        // 原援用
        System.out.println("reference 初始值:" + reference);

        // 新起一个线程用来首次更改
        Thread t1 = new Thread(new Runnable() {public void run() {Integer reference = atomicReference.get();
                System.out.println(reference + "------"
                        + atomicReference.compareAndSet(reference, reference + 10));
            }
        });

        // 改回原值
        Thread t2 = new Thread(new Runnable() {public void run() {Integer reference = atomicReference.get();
                System.out.println(reference + "------"
                        + atomicReference.compareAndSet(reference, reference - 10));
            }
        });

        // 再做 CAS
        Thread t3 = new Thread(new Runnable() {public void run() {Integer reference = atomicReference.get();
                System.out.println(reference + "------"
                        + atomicReference.compareAndSet(reference, reference + 10));
            }
        });

        // t1,t2,t3 以此执行
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
        t3.join();

        System.out.println(atomicReference.get());
    }

}

运行后果：

reference 初始值:0
0------true
10------true
0------true
10

以上代码能够举个例子：

你倒了一杯水放桌子上，干了点别的事，而后共事把你水喝了又给你从新倒了一杯水，你回来看水还在，拿起来就喝，如果你不论水两头被人喝过，只关怀水还在，这就是 ABA 问题。下面代码就只关注后果没变就能够批改胜利，不关注过程。

public class Test01 {

    // 申明援用值为 0，版本号为 0
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference(0, 0);

    public static void main(String[] args) throws InterruptedException {

        // 原始版本号
        final Integer initialStamp = atomicStampedReference.getStamp();
        // 原始援用
        final Integer initialReference = atomicStampedReference.getReference();
        // 原援用和原版本号
        System.out.println("reference 初始值:" + initialReference + "版本号初始值:" + initialStamp);

        // 新起一个线程用来首次更改
        Thread t1 = new Thread(new Runnable() {public void run() {
                System.out.println(initialReference + "-" + initialStamp + "-"
                        + atomicStampedReference.compareAndSet(initialReference, initialReference + 10, initialStamp, initialStamp + 1));
            }
        });

        Thread t2 = new Thread(new Runnable() {public void run() {Integer stamp = atomicStampedReference.getStamp();
                Integer reference = atomicStampedReference.getReference();
                System.out.println(reference + "-" + stamp + "-"
                        + atomicStampedReference.compareAndSet(reference, reference - 10, stamp, stamp + 1));
            }
        });

        Thread t3 = new Thread(new Runnable() {public void run() {
                // 取到以后援用值和版本号
                Integer stamp = atomicStampedReference.getStamp();
                Integer reference = atomicStampedReference.getReference();
                System.out.println(reference + "-" + stamp + "-"
                        + atomicStampedReference.compareAndSet(initialReference, reference + 10, initialStamp, stamp + 1));
            }
        });

        // t1,t2,t3 程序执行
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
        t3.join();

        System.out.println(atomicStampedReference.getReference());
        System.out.println(atomicStampedReference.getStamp());
    }

}

运行后果：

reference 初始值:0 版本号初始值:0
0-0-true
10-1-true
0-0-false
0
2

剖析：

采纳 AtomicStampedReference 来解决 ABA 问题，t1 线程批改了初始值，并将版本号加 1，t2 线程将值批改回了初始值，然而版本号加 1，t3 线程想要批改初始值，尽管以后值跟初始值相等，然而版本号还是用的原来的，故数据批改失败，解决了 ABA 问题。

CAS 的原理

CAS 所带来的问题

相干原子操作类

AtomicInteger 根本类型

AtomicReference 援用类型

AtomicReference 存在的问题

AtomicStampedReference 解决 ABA 问题