JAVA并发编程：详解原子操作、如何使用CAS实现原子操作、JDK中相关原子操作类的基本使用

1、什么是原子操作？

  假定有两个操作A 和B，如果从执行A 的线程来看，当另一个线程执行B 时，要么将B 全部执行完，要么完全不执行B，那么A 和B 对彼此来说是原子的。

2、如何实现原子操作？

  实现原子操作可以使用锁，锁机制，满足基本的需求是没有问题的了，但是有的时候我们的需求并非这么简单，我们需要更有效，更加灵活的机制，synchronized 关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程需要等待，直到该线程释放锁。

  这里会有些问题：首先，如果被阻塞的线程优先级很高很重要怎么办？其次，如果获得锁的线程一直不释放锁怎么办？（这种情况是非常糟糕的）。还有一种情况，如果有大量的线程来竞争资源，那CPU 将会花费大量的时间和资源来处理这些竞争，同时，还有可能出现一些例如死锁之类的情况，最后，其实锁机制是一种比较粗糙，粒度比较大的机制，相对于像计数器这样的需求有点儿过于笨重。
  实现原子操作还可以使用当前的处理器基本都支持CAS()的指令，只不过每个厂家所实现的算法并不一样，每一个CAS 操作过程都包含三个运算符：

• 一个内存地址V
• 一个期望的值A
• 一个新值B

  操作的时候如果这个地址上存放的值等于这个期望的值A，则将地址上的值赋为新值B，否则不做任何操作。
  CAS 的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事儿，但是要返回原值是多少。循环CAS 就是在一个循环里不断的做cas 操作，直到成功为止。
  CAS 是怎么实现线程的安全呢？语言层面不做处理，我们将其交给硬件CPU 和内存，利用CPU 的多处理能力，实现硬件层面的阻塞，再加上volatile 变量的特性即可实现基于原子操作的线程安全。

CAS原理

• 利用了现代处理器都支持的CAS指令，循环这个指令，直到成功为止。
  

CAS的问题

• ABA问题
    因为CAS 需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS 进行检查时会发现它的值没有发生变化，但是实际上却变化了。
    ABA 问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A 就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA 问题。
    如果你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的时候水被人动过没有，因为你是程序员，所以就想起了放了张纸在旁边，写上初始值0，别人喝水前麻烦先做个累加才能喝水。
    从1.5开始，在JDK的JUC包下提供了AtomicMarkableReference类和AtomicStampedReference类，可以解决ABA问题。AtomicMarkableReference类是通过打标记mark来维护一个对象的引用，而AtomicStampedReference类是通过利用版本戳的形式记录了每次改变以后的版本号，维护一个对象的引用。
• 开销问题
    自旋CAS 如果长时间不成功，会给CPU 带来非常大的执行开销。
• 只能保证一个共享变量的原子操作
    当对一个共享变量执行操作时，我们可以使用循环CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环CAS 就无法保证操作的原子性，这个时候就可以用锁。
    还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS 来操作ij。从Java 1.5开始，JDK 提供了AtomicReference 类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS 操作。

3、JDK中相关原子操作类的使用

  大概可以分为以下几类：

• 更新基本类型类：AtomicBoolean，AtomicInteger，AtomicLong
• 更新数组类：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
• 更新引用类型：原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic 包提供了以下3个类。AtomicReference，AtomicMarkableReference，AtomicStampedReference
• 原子更新字段类： AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater

  主要讲解一下常用的几个原子类，其余的原子类读者有兴趣可自行研究。

3.1 AtomicInteger

常用方法如下：

• int get()：获取当前值
• void set(int newValue)：设置为给定值
• void lazySet(int newValue)：最终设置为给定的值
• int getAndSet(int newValue)：以原子方式设置为给定值并返回旧值
• boolean compareAndSet(int expect, int update)：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
• int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。
• int getAndDecrement()：以原子方式将当前值减1，注意，这里返回的是自减前的值。
• int getAndAdd(int delta)：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回旧值。
• int incrementAndGet()：以原子方式将当前值加1，注意，这里返回的是自增后的值。
• int decrementAndGet()：以原子方式将当前值减1，注意，这里返回的是自减后的值。
• int decrementAndGet()：以原子方式将当前输入值与实例中的值（AtomicInteger里的value）相加，并返回新值。

代码示例如下：

package cn.lspj.ch3;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 类说明：AtomicInteger类的基本使用
 */
public class UseAtomicInteger {
    static AtomicInteger ai = new AtomicInteger(10);

    public static void main(String[] args) {
        System.out.println(ai.get()); // int get()：获取当前值
        ai.set(12); // void set(int newValue)：设置为给定值
        System.out.println(ai.get());
        ai.lazySet(15); // void lazySet(int newValue)：最终设置为给定的值
        System.out.println(ai.get());
        System.out.println(ai.addAndGet(24)); // int getAndSet(int newValue)：以原子方式设置为给定值并返回旧值
        System.out.println(ai.compareAndSet(12,15)); // boolean compareAndSet(int expect, int update)：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
        System.out.println(ai.getAndIncrement()); // int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。
        System.out.println(ai.getAndDecrement()); // int getAndDecrement()：以原子方式将当前值减1，注意，这里返回的是自减前的值。
        System.out.println(ai.getAndAdd(10)); // int getAndAdd(int delta)：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回旧值。
        System.out.println(ai.incrementAndGet()); // int incrementAndGet()：以原子方式将当前值加1，注意，这里返回的是自增后的值。
        System.out.println(ai.decrementAndGet()); // int decrementAndGet()：以原子方式将当前值减1，注意，这里返回的是自减后的值。
        System.out.println(ai.addAndGet(10)); // int decrementAndGet()：以原子方式将当前输入值与实力中的值（AtomicInteger里的value）相加，并返回新值。

    }
}

执行结果如下：

3.2 AtomicIntegerArray

主要是提供原子的方式更新数组里的整型，其常用方法如下：

• int getAndSet(int i, int newValue)：原子地将位置{@code i}的元素设置为给定的值并返回旧值。
• int addAndGet(int i, int delta)：原子地将给定的值添加到索引{@code i}处的元素并返回新值。
• boolean compareAndSet(int i, int expect, int update)：如果当前值等于预期值，则以原子方式将数组位置{@code i}的元素设置成update值。
• int getAndIncrement(int i)：原子地在索引{@code i}处的值自增1并返回自增前的值。
• int incrementAndGet(int i)：原子地在索引{@code i}处的值自增1并返回自增后的值。
• int getAndDecrement(int i)：原子地在索引{@code i}处的值自减1并返回自减前的值。
• int decrementAndGet(int i)：原子地在索引{@code i}处的值自减1并返回自减后的值。

代码示例如下：

package cn.lspj.ch3;

import java.util.Arrays;
import java.util.concurrent.atomic.AtomicIntegerArray;

/**
 * 类说明：AtomicIntegerArray的基本使用
 */
public class UseAtomicIntegerArray {
    static int[] value = new int[] { 1, 2 };
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    public static void main(String[] args) {
        System.out.println( ai.getAndSet(0, 3)); // int getAndSet(int i, int newValue)：原子地将位置{@code i}的元素设置为给定的值并返回旧值。
        System.out.println(ai.get(0));
        System.out.println(ai.addAndGet(1,5)); // int addAndGet(int i, int delta)：原子地将给定的值添加到索引{@code i}处的元素并返回新值。
        System.out.println(ai.compareAndSet(0,3,30)); // boolean compareAndSet(int i, int expect, int update)：如果当前值等于预期值，则以原子方式将数组位置{@code i}的元素设置成update值。
        System.out.println(ai.getAndIncrement(0)); // int getAndIncrement(int i)：原子地在索引{@code i}处的值自增1并返回自增前的值。
        System.out.println(ai.incrementAndGet(0)); // int incrementAndGet(int i)：原子地在索引{@code i}处的值自增1并返回自增后的值。
        System.out.println(ai.getAndDecrement(0)); // int getAndDecrement(int i)：原子地在索引{@code i}处的值自减1并返回自减前的值。
        System.out.println(ai.decrementAndGet(0)); // int decrementAndGet(int i)：原子地在索引{@code i}处的值自减1并返回自减后的值。
        /**
         * 原数组不会变化：
         * 需要注意的是，数组value 通过构造方法传递进去，然后AtomicIntegerArray
         * 会将当前数组复制一份，所以当 AtomicIntegerArray 对内部的数组元素进行修改
         * 时，不会影响传入的数组。
         */
        System.out.println(Arrays.toString(value)); //

    }
}

执行结果如下：

  需要注意的是，数组value 通过构造方法传递进去，然后AtomicIntegerArray 会将当前数组复制一份，所以当 AtomicIntegerArray对内部的数组元素进行修改 时，不会影响传入的数组，如下图AtomicIntegerArray构造方法中的实现。

3.3 AtomicReference

常用方法如下：

• V get()：获取当前值
• void set(V newValue)：设置为给定值
• V getAndSet(V newValue)：原子地设置给定的值，并返回旧值。
• boolean compareAndSet(V expect, V update)：如果当前值等于预期值（expect），原子地将当前值设置为更新值（update）。
  代码示例如下：

package cn.lspj.ch3;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 类说明：原子更新引用类型，AtomicReference 类的基本使用
 */
public class UseAtomicReference {
    static AtomicReference<UserInfo> atomicUserRef;

    //定义一个实体类
    static class UserInfo {
        private volatile String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return "UserInfo{" +"name='" + name + '\'' +", age=" + age +'}';
        }

        public static void main(String[] args) {
            UserInfo user1 = new UserInfo("Mark", 15);//要修改的实体的实例

            UserInfo user2 = new UserInfo("Mark001", 18);//要修改的实体的实例

            atomicUserRef = new AtomicReference(user1);

            UserInfo updateUser = new UserInfo("Bill", 17); // 修改为此实例的值

            System.out.println(atomicUserRef.compareAndSet(user1, updateUser)); // 更新成功，boolean compareAndSet(V expect, V update)：如果当前值等于预期值（expect），原子地将当前值设置为更新值（update）。
            System.out.println(atomicUserRef.compareAndSet(user2, updateUser)); // 更新失败
            System.out.println(atomicUserRef.get()); // V get()：获取当前值
            atomicUserRef.set(user2); // void set(V newValue)：设置为给定值
            System.out.println(atomicUserRef.get());

            UserInfo user3 = new UserInfo("James001", 20);
            System.out.println(atomicUserRef.getAndSet(user3)); // V getAndSet(V newValue)：原子地设置给定的值，并返回旧值。
            System.out.println(atomicUserRef.get()); // 获取更新后的值
            System.out.println(user1);
        }
    }
}

执行结果如下：

3.4 AtomicStampedReference

  利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在ABA问题了。这就是AtomicStampedReference 的解决方案。AtomicMarkableReference跟AtomicStampedReference 差不多，AtomicStampedReference 是使用pair 的int stamp 作为计数器使用，AtomicMarkableReference 的pair 使用的是boolean mark。还是那个水的例子，AtomicStampedReference 可能关心的是动过几次，AtomicMarkableReference 关心的是有没有被人动过，方法都比较简单。

代码示例如下：

package cn.lspj.ch3;

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 类说明：演示带版本戳的原子操作类 AtomicStampedReference
 */
public class UseAtomicStampedReference {

    static AtomicStampedReference<String> asr = new AtomicStampedReference("lisi",0);

    public static void main(String[] args) throws InterruptedException {
        //拿到当前的版本号(旧)
        final int oldStamp = asr.getStamp();
        // 当前变量值
        final String oldReference = asr.getReference();
        System.out.println(oldReference+"============"+oldStamp);

        Thread rightStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":当前变量值："
                        +oldReference + "-当前版本戳：" + oldStamp + "-"
                        + asr.compareAndSet(oldReference,
                        oldReference + "+学习Java", oldStamp,
                        oldStamp + 1));
            }
        });

        Thread errorStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                String reference = asr.getReference();
                //int oldStamp = asr.getStamp(); // 使用当前版本才能更新成功
                System.out.println(Thread.currentThread().getName()
                        +":当前变量值："
                        +reference + "-当前版本戳：" + asr.getStamp() + "-"
                        + asr.compareAndSet(reference,
                        reference + "+也要学习C", oldStamp,
                        oldStamp + 1));
            }
        });
        rightStampThread.start();
        rightStampThread.join();
        errorStampThread.start();
        errorStampThread.join();

        System.out.println(asr.getReference()+"============"+asr.getStamp());
    }
}

执行结果如下：

3.5 AtomicMarkableReference

  利用标识mark的形式记录更新操作，这样的话就不会存在ABA问题了。这就是 AtomicMarkableReference 的解决方案。

代码示例如下：

package cn.lspj.ch3;

import java.util.concurrent.atomic.AtomicMarkableReference;

/**
 * 类说明：演示带标识的原子操作类 AtomicMarkableReference
 *
 */
public class UseAtomicMarkableReference {

    static AtomicMarkableReference<String> amr = new AtomicMarkableReference("lisi",true);

    public static void main(String[] args) {
        // 获取当前值
        String reference = amr.getReference();
        // 获取当前标识
        boolean marked = amr.isMarked();
        System.out.println("当前值：" + reference + ",mark=" + marked);
        // 更新成功
        System.out.println(amr.compareAndSet(reference,reference+ "学习Java",marked,false));
        System.out.println("当前值：" + amr.getReference() + ",mark=" + amr.isMarked());

        // 更新失败
        System.out.println(amr.compareAndSet(reference,reference+ "也要学习C",marked,false));
        System.out.println("当前值：" + amr.getReference() + ",mark=" + amr.isMarked());
    }

}

执行结果如下：

---

备注：博主微信公众号，不定期更新文章，欢迎扫码关注。