并发编程大师系列之:原子操作类CAS

/ 并发编程 / 0 条评论 / 379人围观

CAS(compare and swap),即:比较然后交换。

CAS的原理

  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());

    }

}

打印结果:

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问题。