JUC 中的 Atomic 原子类总结

1 Atomic 原子类介绍

Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util.concurrent 的原子类都存放在java.util.concurrent.atomic下,如下图所示。

JUC原子类概览

根据操作的数据类型，可以将JUC包中的原子类分为4类

基本类型

使用原子的方式更新基本类型

  • AtomicInteger：整型原子类
  • AtomicLong：长整型原子类
  • AtomicBoolean ：布尔型原子类

数组类型

使用原子的方式更新数组里的某个元素

  • AtomicIntegerArray：整型数组原子类
  • AtomicLongArray：长整型数组原子类
  • AtomicReferenceArray ：引用类型数组原子类

引用类型

  • AtomicReference：引用类型原子类
  • AtomicReferenceFieldUpdater：原子更新引用类型里的字段
  • AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型

  • AtomicIntegerFieldUpdater:原子更新整型字段的更新器
  • AtomicLongFieldUpdater：原子更新长整型字段的更新器
  • AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
  • AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来，也可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

CAS ABA 问题

  • 描述: 第一个线程取到了变量 x 的值 A，然后巴拉巴拉干别的事，总之就是只拿到了变量 x 的值 A。这段时间内第二个线程也取到了变量 x 的值 A，然后把变量 x 的值改为 B，然后巴拉巴拉干别的事，最后又把变量 x 的值变为 A （相当于还原了）。在这之后第一个线程终于进行了变量 x 的操作，但是此时变量 x 的值还是 A，所以 compareAndSet 操作是成功。
  • 例子描述(可能不太合适，但好理解): 年初，现金为零，然后通过正常劳动赚了三百万，之后正常消费了（比如买房子）三百万。年末，虽然现金零收入（可能变成其他形式了），但是赚了钱是事实，还是得交税的！
  • 代码例子（以AtomicInteger为例）
  1. import java.util.concurrent.atomic.AtomicInteger;
  3. public class AtomicIntegerDefectDemo {
  4.     public static void main(String[] args) {
  5.         defectOfABA();
  6.     }
  8.     static void defectOfABA() {
  9.         final AtomicInteger atomicInteger = new AtomicInteger(1);
  11.         Thread coreThread = new Thread(
  12.                 () -> {
  13.                     final int currentValue = atomicInteger.get();
  14.                     System.out.println(Thread.currentThread().getName() + " ------ currentValue=" + currentValue);
  16.                     // 这段目的：模拟处理其他业务花费的时间
  17.                     try {
  18.                         Thread.sleep(300);
  19.                     } catch (InterruptedException e) {
  20.                         e.printStackTrace();
  21.                     }
  23.                     boolean casResult = atomicInteger.compareAndSet(1, 2);
  24.                     System.out.println(Thread.currentThread().getName()
  25.                             + " ------ currentValue=" + currentValue
  26.                             + ", finalValue=" + atomicInteger.get()
  27.                             + ", compareAndSet Result=" + casResult);
  28.                 }
  29.         );
  30.         coreThread.start();
  32.         // 这段目的：为了让 coreThread 线程先跑起来
  33.         try {
  34.             Thread.sleep(100);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  39.         Thread amateurThread = new Thread(
  40.                 () -> {
  41.                     int currentValue = atomicInteger.get();
  42.                     boolean casResult = atomicInteger.compareAndSet(1, 2);
  43.                     System.out.println(Thread.currentThread().getName()
  44.                             + " ------ currentValue=" + currentValue
  45.                             + ", finalValue=" + atomicInteger.get()
  46.                             + ", compareAndSet Result=" + casResult);
  48.                     currentValue = atomicInteger.get();
  49.                     casResult = atomicInteger.compareAndSet(2, 1);
  50.                     System.out.println(Thread.currentThread().getName()
  51.                             + " ------ currentValue=" + currentValue
  52.                             + ", finalValue=" + atomicInteger.get()
  53.                             + ", compareAndSet Result=" + casResult);
  54.                 }
  55.         );
  56.         amateurThread.start();
  57.     }
  58. }

输出内容如下：

  1. Thread-0 ------ currentValue=1
  2. Thread-1 ------ currentValue=1, finalValue=2, compareAndSet Result=true
  3. Thread-1 ------ currentValue=2, finalValue=1, compareAndSet Result=true
  4. Thread-0 ------ currentValue=1, finalValue=2, compareAndSet Result=true

下面我们来详细介绍一下这些原子类。

2 基本类型原子类

2.1 基本类型原子类介绍

使用原子的方式更新基本类型

  • AtomicInteger：整型原子类
  • AtomicLong：长整型原子类
  • AtomicBoolean ：布尔型原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicInteger 为例子来介绍。

AtomicInteger 类常用方法

  1. public final int get() //获取当前的值
  2. public final int getAndSet(int newValue)//获取当前的值，并设置新的值
  3. public final int getAndIncrement()//获取当前的值，并自增
  4. public final int getAndDecrement() //获取当前的值，并自减
  5. public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
  6. boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
  7. public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

2.2 AtomicInteger 常见方法使用

  1. import java.util.concurrent.atomic.AtomicInteger;
  3. public class AtomicIntegerTest {
  5.     public static void main(String[] args) {
  6.         // TODO Auto-generated method stub
  7.         int temvalue = 0;
  8.         AtomicInteger i = new AtomicInteger(0);
  9.         temvalue = i.getAndSet(3);
  10.         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:0;  i:3
  11.         temvalue = i.getAndIncrement();
  12.         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:3;  i:4
  13.         temvalue = i.getAndAdd(5);
  14.         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:4;  i:9
  15.     }
  17. }

2.3 基本数据类型原子类的优势

通过一个简单例子带大家看一下基本数据类型原子类的优势

①多线程环境不使用原子类保证线程安全（基本数据类型）

  1. class Test {
  2.         private volatile int count = 0;
  3.         //若要线程安全执行执行count++，需要加锁
  4.         public synchronized void increment() {
  5.                   count++; 
  6.         }
  8.         public int getCount() {
  9.                   return count;
  10.         }
  11. }

②多线程环境使用原子类保证线程安全（基本数据类型）

  1. class Test2 {
  2.         private AtomicInteger count = new AtomicInteger();
  4.         public void increment() {
  5.                   count.incrementAndGet();
  6.         }
  7.       //使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
  8.        public int getCount() {
  9.                 return count.get();
  10.         }
  11. }

2.4 AtomicInteger 线程安全原理简单分析

AtomicInteger 类的部分源码：

  1.     // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
  2.     private static final Unsafe unsafe = Unsafe.getUnsafe();
  3.     private static final long valueOffset;
  5.     static {
  6.         try {
  7.             valueOffset = unsafe.objectFieldOffset
  8.                 (AtomicInteger.class.getDeclaredField("value"));
  9.         } catch (Exception ex) { throw new Error(ex); }
  10.     }
  12.     private volatile int value;

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。

3 数组类型原子类

3.1 数组类型原子类介绍

使用原子的方式更新数组里的某个元素

  • AtomicIntegerArray：整形数组原子类
  • AtomicLongArray：长整形数组原子类
  • AtomicReferenceArray ：引用类型数组原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。

AtomicIntegerArray 类常用方法

  1. public final int get(int i) //获取 index=i 位置元素的值
  2. public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
  3. public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
  4. public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
  5. public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
  6. boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
  7. public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

3.2 AtomicIntegerArray 常见方法使用

  2. import java.util.concurrent.atomic.AtomicIntegerArray;
  4. public class AtomicIntegerArrayTest {
  6.     public static void main(String[] args) {
  7.         // TODO Auto-generated method stub
  8.         int temvalue = 0;
  9.         int[] nums = { 1, 2, 3, 4, 5, 6 };
  10.         AtomicIntegerArray i = new AtomicIntegerArray(nums);
  11.         for (int j = 0; j < nums.length; j++) {
  12.             System.out.println(i.get(j));
  13.         }
  14.         temvalue = i.getAndSet(0, 2);
  15.         System.out.println("temvalue:" + temvalue + ";  i:" + i);
  16.         temvalue = i.getAndIncrement(0);
  17.         System.out.println("temvalue:" + temvalue + ";  i:" + i);
  18.         temvalue = i.getAndAdd(0, 5);
  19.         System.out.println("temvalue:" + temvalue + ";  i:" + i);
  20.     }
  22. }

4 引用类型原子类

4.1 引用类型原子类介绍

基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用 引用类型原子类。

  • AtomicReference：引用类型原子类
  • AtomicStampedReference：原子更新引用类型里的字段原子类
  • AtomicMarkableReference ：原子更新带有标记位的引用类型

上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。

4.2 AtomicReference 类使用示例

  1. import java.util.concurrent.atomic.AtomicReference;
  3. public class AtomicReferenceTest {
  5.     public static void main(String[] args) {
  6.         AtomicReference<Person> ar = new AtomicReference<Person>();
  7.         Person person = new Person("SnailClimb", 22);
  8.         ar.set(person);
  9.         Person updatePerson = new Person("Daisy", 20);
  10.         ar.compareAndSet(person, updatePerson);
  12.         System.out.println(ar.get().getName());
  13.         System.out.println(ar.get().getAge());
  14.     }
  15. }
  17. class Person {
  18.     private String name;
  19.     private int age;
  21.     public Person(String name, int age) {
  22.         super();
  23.         this.name = name;
  24.         this.age = age;
  25.     }
  27.     public String getName() {
  28.         return name;
  29.     }
  31.     public void setName(String name) {
  32.         this.name = name;
  33.     }
  35.     public int getAge() {
  36.         return age;
  37.     }
  39.     public void setAge(int age) {
  40.         this.age = age;
  41.     }
  43. }

上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下：

  1. Daisy
  2. 20

4.3 AtomicStampedReference 类使用示例

  1. import java.util.concurrent.atomic.AtomicStampedReference;
  3. public class AtomicStampedReferenceDemo {
  4.     public static void main(String[] args) {
  5.         // 实例化、取当前值和 stamp 值
  6.         final Integer initialRef = 0, initialStamp = 0;
  7.         final AtomicStampedReference<Integer> asr = new AtomicStampedReference<>(initialRef, initialStamp);
  8.         System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
  10.         // compare and set
  11.         final Integer newReference = 666, newStamp = 999;
  12.         final boolean casResult = asr.compareAndSet(initialRef, newReference, initialStamp, newStamp);
  13.         System.out.println("currentValue=" + asr.getReference()
  14.                 + ", currentStamp=" + asr.getStamp()
  15.                 + ", casResult=" + casResult);
  17.         // 获取当前的值和当前的 stamp 值
  18.         int[] arr = new int[1];
  19.         final Integer currentValue = asr.get(arr);
  20.         final int currentStamp = arr[0];
  21.         System.out.println("currentValue=" + currentValue + ", currentStamp=" + currentStamp);
  23.         // 单独设置 stamp 值
  24.         final boolean attemptStampResult = asr.attemptStamp(newReference, 88);
  25.         System.out.println("currentValue=" + asr.getReference()
  26.                 + ", currentStamp=" + asr.getStamp()
  27.                 + ", attemptStampResult=" + attemptStampResult);
  29.         // 重新设置当前值和 stamp 值
  30.         asr.set(initialRef, initialStamp);
  31.         System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
  33.         // [不推荐使用，除非搞清楚注释的意思了] weak compare and set
  34.         // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
  35.         // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
  36.         // so is only rarely an appropriate alternative to compareAndSet."
  37.         // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
  38.         final boolean wCasResult = asr.weakCompareAndSet(initialRef, newReference, initialStamp, newStamp);
  39.         System.out.println("currentValue=" + asr.getReference()
  40.                 + ", currentStamp=" + asr.getStamp()
  41.                 + ", wCasResult=" + wCasResult);
  42.     }
  43. }

输出结果如下：

  1. currentValue=0, currentStamp=0
  2. currentValue=666, currentStamp=999, casResult=true
  3. currentValue=666, currentStamp=999
  4. currentValue=666, currentStamp=88, attemptStampResult=true
  5. currentValue=0, currentStamp=0
  6. currentValue=666, currentStamp=999, wCasResult=true

4.4 AtomicMarkableReference 类使用示例

  1. import java.util.concurrent.atomic.AtomicMarkableReference;
  3. public class AtomicMarkableReferenceDemo {
  4.     public static void main(String[] args) {
  5.         // 实例化、取当前值和 mark 值
  6.         final Boolean initialRef = null, initialMark = false;
  7.         final AtomicMarkableReference<Boolean> amr = new AtomicMarkableReference<>(initialRef, initialMark);
  8.         System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked());
  10.         // compare and set
  11.         final Boolean newReference1 = true, newMark1 = true;
  12.         final boolean casResult = amr.compareAndSet(initialRef, newReference1, initialMark, newMark1);
  13.         System.out.println("currentValue=" + amr.getReference()
  14.                 + ", currentMark=" + amr.isMarked()
  15.                 + ", casResult=" + casResult);
  17.         // 获取当前的值和当前的 mark 值
  18.         boolean[] arr = new boolean[1];
  19.         final Boolean currentValue = amr.get(arr);
  20.         final boolean currentMark = arr[0];
  21.         System.out.println("currentValue=" + currentValue + ", currentMark=" + currentMark);
  23.         // 单独设置 mark 值
  24.         final boolean attemptMarkResult = amr.attemptMark(newReference1, false);
  25.         System.out.println("currentValue=" + amr.getReference()
  26.                 + ", currentMark=" + amr.isMarked()
  27.                 + ", attemptMarkResult=" + attemptMarkResult);
  29.         // 重新设置当前值和 mark 值
  30.         amr.set(initialRef, initialMark);
  31.         System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked());
  33.         // [不推荐使用，除非搞清楚注释的意思了] weak compare and set
  34.         // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
  35.         // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
  36.         // so is only rarely an appropriate alternative to compareAndSet."
  37.         // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
  38.         final boolean wCasResult = amr.weakCompareAndSet(initialRef, newReference1, initialMark, newMark1);
  39.         System.out.println("currentValue=" + amr.getReference()
  40.                 + ", currentMark=" + amr.isMarked()
  41.                 + ", wCasResult=" + wCasResult);
  42.     }
  43. }

输出结果如下：

  1. currentValue=null, currentMark=false
  2. currentValue=true, currentMark=true, casResult=true
  3. currentValue=true, currentMark=true
  4. currentValue=true, currentMark=false, attemptMarkResult=true
  5. currentValue=null, currentMark=false
  6. currentValue=true, currentMark=true, wCasResult=true

5 对象的属性修改类型原子类

5.1 对象的属性修改类型原子类介绍

如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。

  • AtomicIntegerFieldUpdater:原子更新整形字段的更新器
  • AtomicLongFieldUpdater：原子更新长整形字段的更新器
  • AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

要想原子地更新对象的属性需要两步。第一步，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新的对象属性必须使用 public volatile 修饰符。

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerFieldUpdater为例子来介绍。

5.2 AtomicIntegerFieldUpdater 类使用示例

  1. import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  3. public class AtomicIntegerFieldUpdaterTest {
  4.     public static void main(String[] args) {
  5.         AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
  7.         User user = new User("Java", 22);
  8.         System.out.println(a.getAndIncrement(user));// 22
  9.         System.out.println(a.get(user));// 23
  10.     }
  11. }
  13. class User {
  14.     private String name;
  15.     public volatile int age;
  17.     public User(String name, int age) {
  18.         super();
  19.         this.name = name;
  20.         this.age = age;
  21.     }
  23.     public String getName() {
  24.         return name;
  25.     }
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  31.     public int getAge() {
  32.         return age;
  33.     }
  35.     public void setAge(int age) {
  36.         this.age = age;
  37.     }
  39. }

输出结果：

  1. 22
  2. 23