1. 原子列操作介绍

在并发操作中很容易出现并发安全问题，比如i++，可以通过 Synchronized 进行控制来达到线程安全的目的。但是由于 synchronized 是采用的是悲观锁策略，并不是特别高效的一种解决方案。实际上，在J.U.C下的 atomic 包提供了一系列的操作简单，性能高效，并能保证线程安全的类去更新基本类型变量，数组元素，引用类型以及更新对象中的字段类型。

atomic 包下的这些类都是采用的是乐观锁策略去原子更新数据，在 java 中则是使用CAS 操作具体实现。

2. CAS 操作

CAS 又称为无锁操作，是一种乐观锁策略。它假设所有线程访问共享资源的时候不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此，线程就不会出现阻塞停顿的状态。那么，如果出现冲突了怎么办？无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突，出现冲突就重试当前操作直到没有冲突为止。

2.1 CAS 的交换过程

CAS 比较交换的过程可以通俗的理解为CAS(V,O,N)，包含三个值分别为：

  • V 内存地址存放的实际值；
  • O 预期的值（旧值）；
  • N 更新的新值。

当V和O相同时，也就是说旧值和内存中实际的值相同表明该值没有被其他线程更改过，即该旧值O就是目前来说最新的值了，才可以将新值N赋值给V。反之，V和O不相同，表明该值已经被其他线程改过了则该旧值O不是最新版本的值了，所以不能将新值N赋给V，返回V即可。

当多个线程使用CAS操作一个变量是，只有一个线程会成功，并成功更新，其余会失败。失败的线程会重新尝试，当然也可以选择挂起线程

CAS的实现需要硬件指令集的支撑，在 JDK1.5 后虚拟机才可以使用处理器提供的CMPXCHG指令实现。

2.2 Synchronized VS CAS

Synchronized(未优化前)最主要的问题是：在存在线程竞争的情况下会出现线程阻塞和唤醒锁带来的性能问题，因为这是一种互斥同步（阻塞同步）。而 CAS 并不是武断的间线程挂起，当 CAS 操作失败后会进行一定的尝试，而非进行耗时的挂起唤醒的操作，因此也叫做非阻塞同步。这是两者主要的区别。

2.3 CAS 存在的问题

  1. ABA问题：如果变量 V 初次读取的时候值是A，后来变成了B，然后又变成了A，你本来期望的值是第一个A才会设置新值，第二个A跟期望不符合，但却也能设置新值。针对这种情况，java 并发包中提供了一个带有标记的原子引用类 AtomicStampedReference，它可以通过控制变量值的版本号来保证 CAS 的正确性，比较两个值的引用是否一致，如果一致，才会设置新值。
  2. 无限循环问题（自旋）：看源码可知，Atomic 类设置值的时候会进入一个无限循环，只要不成功，就会不停的循环再次尝试。在高并发时，如果大量线程频繁修改同一个值，可能会导致大量线程执行compareAndSet()方法时需要循环 N 次才能设置成功，即大量线程执行一个重复的空循环（自旋），造成大量开销。解决无线循环问题可以使用 java8 中的 LongAdder，分段CAS和自动分段迁移。
  3. 多变量原子问题：只能保证一个共享变量的原子操作。一般的 Atomic 类，只能保证一个变量的原子性，但如果是多个变量呢？可以用 AtomicReference，这个是封装自定义对象的，多个变量可以放一个自定义对象里，然后他会检查这个对象的引用是不是同一个。如果多个线程同时对一个对象变量的引用进行赋值，用 AtomicReference 的 CAS 操作可以解决并发冲突问题。 但是如果遇到ABA问题，AtomicReference 就无能为力了，需要使用 AtomicStampedReference 来解决。


3. 原子更新基本类型

atomic 包提高原子更新基本类型的工具类，主要有这些：

  1. AtomicBoolean：以原子更新的方式更新 boolean；
  2. AtomicInteger：以原子更新的方式更新 Integer;
  3. AtomicLong：以原子更新的方式更新 Long；

这几个类的用法基本一致，这里以 AtomicInteger 为例总结常用的方法

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

还有一些方法，可以查看API，不再赘述。为了能够弄懂 AtomicInteger的 实现原理，以getAndIncrement方法为例，来看下源码：

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

可以看出，该方法实际上是调用了 unsafe 实例的 getAndAddInt 方法，unsafe 实例的获取时通过 UnSafe 类的静态方法 getUnsafe 获取：

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

Unsafe 类在 sun.misc 包下，Unsafer 类提供了一些底层操作，atomic 包下的原子操作类的也主要是通过 Unsafe 类提供的 compareAndSwapInt，compareAndSwapLong等一系列提供CAS操作的方法来进行实现。下面用一个简单的例子来说明 AtomicInteger的 用法：

  1. public class AtomicDemo {
  2.     private static AtomicInteger atomicInteger = new AtomicInteger(1);
  3.     public static void main(String[] args) {
  4.         System.out.println(atomicInteger.getAndIncrement());
  5.         System.out.println(atomicInteger.get());
  6.     }
  7. }
  8. // 输出结果：
  9. // 1
  10. // 1

atomicInteger 借助了 UnSafe 提供的CAS操作能够保证数据更新的时候是线程安全的，并且由于CAS是采用乐观锁策略，因此，这种数据更新的方法也具有高效性。

AtomicLong 的实现原理和 AtomicInteger 一致，只不过一个针对的是 long 变量，一个针对的是 int 变量。而boolean 变量的更新类 AtomicBoolean 类是怎样实现更新的呢?核心方法是compareAndSett方法，其源码如下：

  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 来实现的。可以看出 atomic 包中只提供了对 boolean,int ,long 这三种基本类型的原子更新的方法，参考对 boolean 更新的方式，原子更新 char,doule,float 也可以采用类似的思路进行实现。

4. 原子更新数组类型

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

  1. AtomicIntegerArray：原子更新整型数组中的元素；
  2. AtomicLongArray：原子更新长整型数组中的元素；
  3. AtomicReferenceArray：原子更新引用类型数组中的元素

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

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

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

  1. public class AtomicDemo {
  2.     //    private static AtomicInteger atomicInteger = new AtomicInteger(1);
  3.     private static int[] value = new int[]{1, 2, 3};
  4.     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

5. 原子更新引用类型

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

  1. AtomicReference：原子更新引用类型；
  2. AtomicReferenceFieldUpdater：原子更新引用类型里的字段；
  3. AtomicMarkableReference：原子更新带有标记位的引用类型；

这几个类的使用方法也是基本一样的，以 AtomicReference 为例，来说明这些类的基本用法。下面是一个 demo

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

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

6. 原子更新字段类型

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

  1. AtomicIntegeFieldUpdater：原子更新整型字段类；
  2. AtomicLongFieldUpdater：原子更新长整型字段类；
  3. AtomicStampedReference：原子更新引用类型，这种更新方式会带有版本号。而为什么在更新的时候会带有版本号，是为了解决 CAS 的 ABA 问题；

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

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

这几个类提供的方法基本一致，以 AtomicIntegerFieldUpdater 为例来看看具体的使用：

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

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