java.util.concurrent.atomic下的所有原子操作类都实现了 CAS。

AtomicInteger 内部维护一个变量 Unsafe：

  1. private static final Unsafe unsafe = Unsafe.getUnsafe();

Unsafe 类中可以执行以下几种操作：

  • 分配内存，释放内存。allocateMemory，reallocateMemory，freeMemory
  • 挂起和唤醒线程。被封装在 LockSupport 类中供使用
  • CAS 操作

J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。

以下代码使用了 AtomicInteger 执行了自增的操作。

  1. private AtomicInteger cnt = new AtomicInteger();
  3. public void add() {
  4.     cnt.incrementAndGet();
  5. }

以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。

  1. public final int incrementAndGet() {
  2.     return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
  3. }

以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。

可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。

  1. public final int getAndAddInt(Object var1, long var2, int var4) {
  2.     int var5;
  3.     do {
  4.         var5 = this.getIntVolatile(var1, var2);
  5.     } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
  7.     return var5;
  8. }

1. 原子更新基本类

atomic 包提高原子更新基本类的工具类，如下：

  • AtomicBoolean
  • AtomicInteger
  • AtomicLong

以 AtomicInteger 为例总结常用的方法:

  1. addAndGet(int delta) //以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果
  3. incrementAndGet() //以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果
  5. getAndSet(int newValue) //将实例中的值更新为新值，并返回旧值
  7. getAndIncrement() //以原子的方式将实例中的原值加1，返回的是自增前的旧值

AtomicInteger 的 getAndIncrement() 方法源码如下：

  1. public final int getAndIncrement() {
  2.     return unsafe.getAndAddInt(this, valueOffset, 1);
  3. }

测试用例：

  1. public class AtomicIntegerDemo {
  2.     // 请求总数
  3.     public static int clientTotal = 5000;
  5.     // 同时并发执行的线程数
  6.     public static int threadTotal = 200;
  8.     //java.util.concurrent.atomic.AtomicInteger;
  9.     public static AtomicInteger count = new AtomicInteger(0);
  11.     public static void main(String[] args) throws InterruptedException {
  12.         ExecutorService executorService = Executors.newCachedThreadPool();
  13.         //Semaphore和CountDownLatch模拟并发
  14.         //Semaphore 控制并发的数量
  15.         //CountDownLatch 用于控制一个线程等待多个线程
  16.         final Semaphore semaphore = new Semaphore(threadTotal);
  17.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
  18.         for (int i = 0; i < clientTotal ; i++) {
  19.             executorService.execute(() -> {
  20.                 try {
  21.                     semaphore.acquire();
  22.                     add();
  23.                     semaphore.release();
  24.                 } catch (Exception e) {
  25.                     e.printStackTrace();
  26.                 }
  27.                 countDownLatch.countDown();
  28.             });
  29.         }
  30.         countDownLatch.await();
  31.         executorService.shutdown();
  32.         System.out.println("count:{"+count.get()+"}");
  33.     }
  35.     public static void add() {
  36.         count.incrementAndGet();
  37.     }
  38. }
  39. /*    输出结果：
  40.         count:{5000}
  41. */

AtomicLong 的实现原理和 AtomicInteger 一致，只不过针对的是 long 变量。
boolean 变量的更新类 AtomicBoolean 类核心方法是 compareAndSet() 方法，其源码如下：

  1. public final boolean compareAndSet(boolean expect, boolean update) {
  2.     int e = expect ? 1 : 0;
  3.     int u = update ? 1 : 0;
  4.     return unsafe.compareAndSwapInt(this, valueOffset, e, u);
  5. }

可以看出，compareAndSet 方法的实际上也是先转换成 0,1 的整型变量，然后是通过针对 int 型变量的原子更新方法 compareAndSwapInt 来实现的。

2. 原子更新数组

atomic 包下提供能原子更新数组中元素的类有：

  • AtomicIntegerArray
  • AtomicLongArray
  • AtomicReferenceArray

这几个类的用法一致，就以AtomicIntegerArray来总结下常用的方法：

  1. getAndAdd(int i, int delta) //以原子更新的方式将数组中索引为i的元素与输入值相加
  3. getAndIncrement(int i) //以原子更新的方式将数组中索引为i的元素自增加1
  5. compareAndSet(int i, int expect, int update) //将数组中索引为i的位置的元素进行更新

可以看出，AtomicIntegerArray 与AtomicInteger 的方法基本一致，只不过在 AtomicIntegerArray 的方法中会多一个指定数组索引位 i。

  1. public class AtomicIntegerArrayDemo {
  2.     private static int[] value = new int[]{1, 2, 3};
  3.     private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);
  5.     public static void main(String[] args) {
  6.         //对数组中索引为1的位置的元素加5
  7.         int result = integerArray.getAndAdd(1, 5);
  8.         System.out.println(integerArray.get(1));
  9.         System.out.println(result);
  10.     }
  11. }
  12. /*    输出结果：
  13.         7
  14.         2  //注意仍然返回原来的旧值
  15. */

3. 原子更新引用类型

如果需要原子更新引用类型变量的话，为了保证线程安全，atomic 也提供了相关的类：

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

这几个类的使用方法也是基本一样的，以AtomicReference为例。

  1. public class AtomicReferenceDemo {
  3.     private static AtomicReference<User> reference = new AtomicReference<>();
  5.     public static void main(String[] args) {
  6.         User user1 = new User("a", 1);
  7.         reference.set(user1);
  8.         User user2 = new User("b",2);
  9.         User user = reference.getAndSet(user2);
  10.         System.out.println(user);
  11.         System.out.println(reference.get());
  12.     }
  14.     static class User {
  15.         private String userName;
  16.         private int age;
  18.         public User(String userName, int age) {
  19.             this.userName = userName;
  20.             this.age = age;
  21.         }
  23.         @Override
  24.         public String toString() {
  25.             return "User{" +
  26.                     "userName='" + userName + '\'' +
  27.                     ", age=" + age +
  28.                     '}';
  29.         }
  30.     }
  31. }
  32. /* 输出结果：
  33.     User{userName='a', age=1}
  34.     User{userName='b', age=2}
  35. */

首先将对象 user1 用 AtomicReference 进行封装，然后调用 getAndSet 方法，从结果可以看出，该方法会原子更新引用的 User 对象，变为User{userName='b', age=2}，返回的是原来的User 对象User{userName='a', age=1}。

4. 原子更新字段类型

如果需要更新对象的某个字段，并在多线程的情况下，能够保证线程安全，atomic同样也提供了相应的原子操作类：

  • AtomicIntegeFieldUpdater
  • AtomicLongFieldUpdater
  • AtomicStampedReference。原子更新引用类型，这种更新方式会带有版本号，为了解决 CAS 的 ABA 问题。

要想使用原子更新字段需要两步操作：

  • 原子更新字段类都是抽象类，只能通过静态方法 newUpdater 来创建一个更新器，并且需要设置想要更新的类和属性
  • 更新类的属性必须使用 public volatile 进行修饰

这几个类提供的方法基本一致，以 AtomicIntegerFieldUpdater 为例。

  1. public class AtomicIntegerFieldUpdaterDemo {
  2.     private static AtomicIntegerFieldUpdater updater =
  3.         AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
  5.     public static void main(String[] args) {
  6.         User user = new User("a", 1);
  7.         int oldValue = updater.getAndAdd(user, 5);
  8.         System.out.println(oldValue);
  9.         System.out.println(updater.get(user));
  10.     }
  12.     static class User {
  13.         private String userName;
  14.         public volatile int age;
  16.         public User(String userName, int age) {
  17.             this.userName = userName;
  18.             this.age = age;
  19.         }
  21.         @Override
  22.         public String toString() {
  23.             return "User{" +
  24.                     "userName='" + userName + '\'' +
  25.                     ", age=" + age +
  26.                     '}';
  27.         }
  28.     }
  29. }
  31. /*    输出结果：
  32.             1
  33.             6
  34. */

创建 AtomicIntegerFieldUpdater 是通过它提供的静态方法进行创建，getAndAdd 方法会将指定的字段加上输入的值，并且返回相加之前的值。
User对象中 age 字段原值为 1，加 5 之后，可以看出 user 对象中的 age 字段的值已经变成了 6。