学习Java并发编程中的Atomic原子库

在之前的博文中，我们已经学习了volatile关键字，了解到它可以保证有序性和可见性，但无法保障原子性。解决原子性问题时，推荐使用synchronized、Lock或者AtomicInteger。我们还学习过CAS算法，提及了atomic。今天，我们将深入学习Atomic原子库，这是一个基于CAS算法实现的高效并发工具库。

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

一、Atomic释义

Atomic翻译为“原子”，何为原子？在化学领域的原子被认为是构成化学反应的最小微观粒子，是不可分割的最小单位。伟大的Doug Lea大师，将并发的一些类以此单词开头命名，一语中的！

• 原子性在程序中所表达的意思是：一个或者多个操作在CPU执行的过程中不被中断的特性。
• 原子操作在程序中表达的意思是：即最小不可拆分的操作，也就是说操作一旦开始，就不能被打断，直到操作完成。

二、四大原子分类

我们根据操作的数据类型可以将JUC包中的原子类做如下的4种划分：

2.1 基本类型

原子操作的基本类型主要可分为：

1. AtomicBoolean：布尔型原子类；
2. AtomicInteger：整型原子类；
3. AtomicLong：长整型原子类；

这三种方式用法几乎相同，都是以原子更新的方式操作基本类型，我们在这里以AtomicInteger为例看一下它的使用与原理。

1）AtomicInteger的常用方法

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

2）AtomicInteger的使用案例

public class Test {
    public static void main(String[] args) {
        //临时值
        int temvalue = 0;
        AtomicInteger i = new AtomicInteger(0);
        temvalue = i.getAndSet(3);
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:0;  i:3
        temvalue = i.getAndIncrement();
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:3;  i:4
        temvalue = i.getAndAdd(5);
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:4;  i:9
        temvalue = i.incrementAndGet();
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:10;  i:10
    }
}

这里需要注意的一点是getAndIncrement()方法与incrementAndGet()，一个先获值后自增，一个先自增后获值。

3）AtomicInteger的底层原理

我们以getAndIncrement()为例，去跟入它的底层代码会发现，其内部是通过调用UnSafe类的静态方法getUnsafe实现的。UnSafe类在CAS算法的时候有提及，后面我们再单独学习它，其底层是通过CAS，原子性的进行增加值。

public final int getAndIncrement() {
    // 使用Unsafe类中的getAndAddInt方法原子地增加AtomicInteger的当前值
    // 第一个参数this是AtomicInteger的当前实例
    // 第二个参数valueOffset是一个偏移量，它指示在AtomicInteger对象中的哪个位置可以找到实际的int值
    // 第三个参数1表示要加到当前值上的值（即增加的值）
    // 此方法返回的是增加前的原始值
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

Unsafe 类是Java中的一个特殊类，用于执行低级、不安全的操作。getAndIncrement方法就是利用了Unsafe类提供的CAS（Compare-And-Swap）操作来实现原子的increment操作。CAS是一种常用的无锁技术，允许在多线程环境中原子地更新值。

2.2 数组类型

原子操作根据数组类型，可以分为如下几种：

1. AtomicIntegerArray：整形数组原子类
2. AtomicLongArray：长整形数组原子类
3. AtomicReferenceArray：引用类型数组原子类

这三种同样很类似，我们以AtomicIntegerArray为例来介绍一下。

1）AtomicIntegerArray的常用方法

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

2）AtomicIntegerArray的使用案例

public class Test {
    public static void main(String[] args) {
        int temvalue = 0;
        int[] nums = { 1, 2, 3, 4, 5, 6 };
        AtomicIntegerArray i = new AtomicIntegerArray(nums);
        for (int j = 0; j < nums.length; j++) {
            System.out.print(i.get(j));
        }
        System.out.println();
        temvalue = i.getAndSet(0, 2);
        System.out.println("temvalue:" + temvalue + ";  i:" + i);
        temvalue = i.getAndIncrement(0);
        System.out.println("temvalue:" + temvalue + ";  i:" + i);
        temvalue = i.getAndAdd(0, 5);
        System.out.println("temvalue:" + temvalue + ";  i:" + i);
    }
}

输出：

123456
temvalue:1;  i:[2, 2, 3, 4, 5, 6]
temvalue:2;  i:[3, 2, 3, 4, 5, 6]
temvalue:3;  i:[8, 2, 3, 4, 5, 6]

2.3 引用类型

除了如上的2种原子类外，atomic包中还提供了引用类型原子类。大概为如下几种：

1. AtomicReference：原子更新引用类型，使用AtomicReference类保证对象之间的原子性，把多个变量放到一个对象里面进行CAS操作；
2. AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题；
3. AtomicMarkableReference：原子更新带有标记的引用类型，该类将boolean标记与引用关联起来。

常用方法又上述两种类型一致，这里不再赘述，我们直接写一个demo感受一下它的使用吧。

public class TestAtomicReference {

    private static AtomicReference reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user1 = new User("小明", 18);
        reference.set(user1);
        User user2 = new User("小华",20);
        User user = reference.getAndSet(user2);
        System.out.println(user);
        System.out.println(reference.get());
    }

    static class User {
        private String userName;
        private int age;

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

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

输出：

User{userName='小明', age=18}
User{userName='小华', age=20}

2.4 对象的属性修改类型

除了原子更新对象（引用类型）外，atomic中还提供了更新对象的属性字段的原子类：

1. AtomicIntegerFieldUpdater:原子更新整形字段的更新器；
2. AtomicLongFieldUpdater：原子更新长整形字段的更新器；
3. AtomicReferenceFieldUpdater：原子更新引用类型里的字段的更新器。

如果想要原子的更新对象的属性，实现起来较上面几种类型略微复杂一下，大概分为两步：

步骤1??
通过静态方法newUpdater创建一个更新器，并且设置想要更新的类和字段；

步骤2??
字段必须使用public volatile进行修饰；

以AtomicIntegerFieldUpdater为例，我们写一个测试类感受一下。

public class TestAtomicIntegerFieldUpdater {
    //创建一个age的更新器
    private static AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");

    public static void main(String[] args) {
        User user = new User("小明", 17);
        int oldValue = updater.getAndAdd(user, 1);
        System.out.println(oldValue);//17
        System.out.println(updater.get(user));//18
    }

    static class User {
        private String userName;
        public volatile int age;

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

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

通过AtomicIntegerFieldUpdater.newUpdater(User.class,"age")创建一个age的更新器，然后调用getAndAdd(user, 1)进行年龄加1操作，从17岁变为18岁。