关于java:CAS

119次阅读

共计 4772 个字符，预计需要花费 12 分钟才能阅读完成。

CAS 的原理

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

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

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

CAS 所带来的问题

  1. ABA 问题。

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

  1. 零碎开销问题。

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

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

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

相干原子操作类

  1. 根本类型类：AtomicBoolean，AtomicInteger，AtomicLong
  2. 数组类：AtomicIntegerArray，AtomicLongArray
  3. 援用类型：AtomicReference，AtomicMarkableReference，AtomicStampedReference
  4. 原子更新字段类：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 问题。

正文完
java
发表至： java
2020-08-16
 0
关于java:JVM故障诊断和处理工具
关于java:生产事故MongoDB复合索引引发的灾难
关于java:Java中使用的API总结
关于java:kafka原理剖析1producer的启动和初始化