关于java:CAS

CAS的原理

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

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

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

CAS所带来的问题

ABA问题。

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

零碎开销问题。

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

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

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

相干原子操作类

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

AtomicInteger根本类型

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

AtomicReference援用类型

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对象，他们两个在被包装的时候就曾经不同了。

AtomicReference存在的问题

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问题。下面代码就只关注后果没变就能够批改胜利，不关注过程。

AtomicStampedReference解决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问题

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:CAS

CAS的原理

CAS所带来的问题

相干原子操作类

AtomicInteger根本类型

AtomicReference援用类型

AtomicReference存在的问题

AtomicStampedReference解决ABA问题

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复