Java 并发编程（二十）：原子操作类

版权声明：本文为博主原创文章，转载请注明出处 https://blog.csdn.net/u010647035/article/details/88373241

1、简介

当需要更新一个变量时，如果多个线程同时更新，可能得到不正确的值，比如变量 i=1，线程A操作 i+1,线程B也操作 i+1，最终可能得到结果 i=2 ，而不是 i=3。

因为两个线程在更新变量 i 时，拿到的都是 i=1，这就是线程不安全的操作。通常我们会用synchronized 来解决这个问题，synchronized 会保证多线程不会同时更新变量i。

Java 从JDK 1.5 开始提供了 java.util.concurrent.atomic 包，这个包中的原子操作类提供了一种简单高效、线程安全更新变量的方式。

在 Atomic 包里提供了13个原子操作类，分为4中类型，分别是：原子更新基本类型、原子更新数组类型、原子更新引用类型、原子更新属性类型。这13个类基本都是使用Unsafe 实现的包装类，底层实现原理就是使用 CAS 机制来实现原子操作的。关于 CAS 的实现原理，见：https://blog.csdn.net/u010647035/article/details/88370551

2、原子更新基本类型

AtomicBoolean 原子更新布尔类型、AtomicInteger 原子更新整形、AtomicLong 原子更新长整型

这三个类提供的方法几乎一致，这里以 AtomicInteger 为例进行讲解，AtomicInteger 提供的方法如下：

1）public final int addAndGet(int delta)

以原子的方式，将输入的数值与实例的数值相加，并返回结果

2）public final boolean compareAndSet(int expect, int update)

如果 expect 值等于当前实例值，则将当前实例值更新为 update 值。

3）public final int getAndIncrement()

以原子方式将当前值加1，并返回原值

4）public final void lazySet(int newValue)

最终会设置为newValue，使用 lazySet 设置值后，可能会导致其它线程在之后的一段时间内还是可以读取到旧的值

5）public final int getAndSet(int newValue)

原子方式设置为 newValue 并返回旧值

6）public final int getAndDecrement()

以原子方式将当前值加1，并返回旧值

7）public final int getAndAdd(int delta)

以原子方式将当前值加 delta，并返回旧值

8）public final int incrementAndGet()

以原子方式将当前值加1，并返回计算后的值

9）public final int decrementAndGet()

以原子方式将当前值减1，并返回计算后的值

10）public final int getAndUpdate(IntUnaryOperator updateFunction)

使用给定函数计算的结果以原子方式更新当前值，并返回旧值

11）public final int updateAndGet(IntUnaryOperator updateFunction)

使用给定函数计算的结果以原子方式更新当前值，并返回计算后的值

12）public final int getAndAccumulate(int x,IntBinaryOperator accumulatorFunction)

使用给定的函数与给定的值计算出一个新值，用这个新值更新当前实例的值，并返回旧值

13）public final int accumulateAndGet(int x,IntBinaryOperator accumulatorFunction)

使用给定的函数与给定的值计算出一个新值，用这个新值更新当前实例的值，并返回新值

14）public final boolean weakCompareAndSet(int expect, int update)

2.1、AtomicInteger 实现原子操作的原理

2.1.1、AtomicInteger 使用示例

 public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);
        System.out.println("getAndIncrement:" + atomicInteger.getAndIncrement());
        System.out.println("get:" + atomicInteger.get());
    }

输出：

getAndIncrement：1
get：2

AtomicInteger 是如何实现原子操作的呢，它的原理又是什么，下面我们看一下 getAndIncrement 的源码

2.1.2、getAndIncrement 源码

//java.util.concurrent.atomic.AtomicInteger
 public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

//sun.misc.Unsafe
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

我们可以看到 getAndIncrement 调用了 unsafe 的 getAndAddInt，getAndAddInt调用了Unsafe的native方法：getIntVolatile 和 compareAndSwapInt，在do-while循环中先取得当前值，然后通过CAS判断当前值是否和current 一致，如果一致意味着值没被其他线程修改过，把当前值设置为当前值+var4，，如果不相等程序进入信的CAS循环。

由于atomic只提供了int,long和boolean的原子操作类，那么其他的基本类型，如byte,char,float,double如何实现原子操作呢，原子操作都是通过Unsafe实现的，让我们看一下Unsafe的实现

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

通过代码，我们发现 Unsafe 只提供了3种CAS方法：compareAndSwapObject、compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现它是先把Boolean转换成整型，再使用compareAndSwapInt 进行CAS，所以原子更新char、float和double变量也可以用类似的思路来实现。

2.2、lazySet 方法是如何工作的

2.2.1、简介

为一个AtomicLong对象设置一个值，jvm会确保其他线程读取到最新值，原子类和voliatile变量也是一样的，这是由依赖于硬件的系统指令(如x86的xchg)实现的。lazySet却是无法保证这一点的方法，所以其他线程在之后的一小段时间里还是可以读到旧的值。

2.2.2、好处

在多核处理器下，内存以及cpu缓存的读和写常常是顺序执行的，所以在多个cpu缓存之间同步一个内存值的代价是很昂贵的。

2.2.3、如何实现

大多数的原子类，比如AtomicLong本质上都是一个 Unsafe 和一个 volatile Long变量的包装类。值得注意的是 AtomicLong.lazySet 方法实际是调用了本地方法 Unsafe.putOrderedLong，从Unsafe的代码中可以发现 Unsafe_setOrderedLong 是一个本地方法（c++实现），它仅调用了 SET_FIELD_VOLATILE，这很是奇怪，我们期望共享的 Unsafe_setLongVolatile 拥有不同的语义。

参考资料：http://ifeve.com/how-does-atomiclong-lazyset-work/

2.3、compareAndSet 与 weakCompareAndSet 区别

暂时未弄明白

3、原子更新数组类型

通过原子方式更新数组中的某个元素，Atomic 包提供了以下3个类，分别是：

AtomicIntegerArray：原子更新整形数组里的元素

AtomicLongArray：原子更新长整形数组里的元素

AtomicReferenceArray：原子更新引用数组里的元素

因为每个类里面提供的方法都一致，因此以 AtomicIntegerArray 为例来说明。
　　
AtomicIntegerArray主要提供了以原子方式更新数组里的整数，常见方法如下：

int addAndGet(int i, int delta)： 以原子的方式将输入值与数组中索引为i的元素相加

boolean compareAndSet(int i, int expect, int update)： 如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

AtomicIntegerArray 应用示例：

public class AtomicIntegerArrayTest {
    private static int[] value = new int[]{1, 2, 3};
    private static AtomicIntegerArray atomicInteger = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        atomicInteger.getAndSet(0, 9);
        System.out.println(atomicInteger.get(0));
        System.out.println(value[0]);
    }
}

输出：

9
1

数组v alue 通过构造方法传递进去，然后 AtomicIntegerArray 会将当前数组复制一份，所以当 AtomicIntegerArray 对内部的数组元素进行修改时，不会影响传入的数组。

4、原子更新引用类型

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

原子引用类型atomic包主要提供了以下几个类：

AtomicReference： 原子更新引用类型

AtomicReferenceFieldUpdater： 原子更新引用类型里的字段

AtomicMarkableReference： 原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是 AtomicMarkableReference（V initialRef，booleaninitialMark）

以上类中提供的方法基本一致，我们以AtomicReference为例说明：

public class AtomicReferenceTest {
    private static AtomicReference<User> reference = new AtomicReference<User>();

    public static void main(String[] args) {
        User user = new User("Jack", 21);
        reference.set(user);

        User updateUser = new User("Jonse", 28);
        reference.compareAndSet(user, updateUser);
        
        System.out.println(reference.get().getName());
        System.out.println(reference.get().getAge());
    }


    static class User {

        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

输出：

Jonse
28

首先创建一个user对象，然后把user对象设置进 AtomicReference 中，最后通过 compareAndSet 做原子更新操作

5、原子更新属性类型

如果需要原子更新某个对象的某个字段，就需要使用原子更新属性的相关类，atomic中提供了一下几个类用于原子更新属性：

AtomicIntegerFieldUpdater： 原子更新整形属性的更新器

AtomicLongFieldUpdater： 原子更新长整形的更新器

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

想要原子的更新字段，需要两个步骤：

1）因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法 newUpdater() 创建一个更新器，并且需要设置想要更新的类和属性

2）更新类的字段（属性）必须使用public volatile修饰符

以 AstomicIntegerFieldUpdater 为例进行讲解，AstomicIntegerFieldUpdater 的示例代码如下：

public class AtomicIntegerFieldUpdaterTest {
    //创建原子更新器，并设置需要更新的对象及属性
    private static AtomicIntegerFieldUpdater<User> updater = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

    public static void main(String[] args) {
        User user = new User("baby", 18);
        //baby长了一岁,输出 18
        System.out.println(updater.getAndIncrement(user));
        //输出19
        System.out.println(updater.get(user));
    }

    static class User {

        private String name;
        public volatile int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

输出结果：
18
19