Java中CAS算法的集中体现：Atomic原子类库，你了解吗？

一、写在开头

在前面的博文中我们学习了volatile关键字，知道了它可以保证有序性和可见性，但无法保障原子性，结局原子性问题推荐使用synchronized、Lock或者AtomicInteger；我们还学习过CAS算法，在那篇博文中我们同样也提及atomic。那么今天，我们就来好好学一学Atomic原子库，一个基于CAS算法实现的高效并发工具库！

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

1.1 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<User> 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}

通过结果我们可以看出先给该reference引用对象set一个user1，再通过getAndSet()方法进行赋值，先输出当前对象数据，紧接着引用指向最新的对象地址，也就是“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岁。