一、写在开头
在前面的博文中我们学习了 volatile 关键字，知道了它可以保证有序性和可见性，但无法保障原子性，结局原子性问题推荐使用 synchronized、Lock 或者 AtomicInteger；我们还学习过 CAS 算法，在那篇博文中我们同样也提及 atomic。那么今天，我们就来好好学一学 Atomic 原子库，一个基于 CAS 算法实现的高效并发工具库！
并发包 java.util.concurrent 的原子类都存放在java.util.concurrent.atomic中，如下图所示：
1.1 Atomic 释义
Atomic 翻译为“原子”，何为原子？在化学领域的原子被认为是构成化学反应的最小微观粒子，是不可分割的最小单位（当然后面又发现了更小的粒子，咱们不杠哈），伟大的 Doug Lea 大师，将并发的一些类以此单词开头命名，一语中的！
二、四大原子分类
我们根据操作的数据类型可以将 JUC 包中的原子类做如下的 4 种划分：
2.1 基本类型
原子操作的基本类型主要可分为：
AtomicBoolean：布尔型原子类；
AtomicInteger：整型原子类；
AtomicLong：长整型原子类；
这三种方式用法几乎相同，都是以原子更新的方式操作基本类型，我们在这里以 AtomicInteger 为例看一下它的使用与原理。
1）AtomicInteger的常用方法
public final int get() //获取当前的值public final int getAndSet(int newValue)//获取当前的值，并设置为newValuepublic final int getAndIncrement()//获取当前的值，并自增public final int incrementAndGet()//增加 1，并获取新值,注意与上面方法区分public final int getAndDecrement() //获取当前的值，并自减public final int getAndAdd(int delta) //获取当前的值，并加上预期的值deltaboolean 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 数组类型
原子操作根据数组类型，可以分为如下几种：
AtomicIntegerArray：整形数组原子类
AtomicLongArray：长整形数组原子类
AtomicReferenceArray：引用类型数组原子类
这三种同样很类似，我们以 AtomicIntegerArray 为例来介绍一下。
1）AtomicIntegerArray的常用方法
public final int get(int i) //获取 index=i 位置元素的值public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValuepublic 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); }}
复制代码
输出：
123456temvalue: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 包中还提供了引用类型原子类。大概为如下几种：
AtomicReference：原子更新引用类型，使用 AtomicReference 类保证对象之间的原子性，把多个变量放到一个对象里面进行 CAS 操作；
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题；
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 中还提供了更新对象的属性字段的原子类：
AtomicIntegerFieldUpdater:原子更新整形字段的更新器；
AtomicLongFieldUpdater：原子更新长整形字段的更新器；
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 岁。
文章转载自：JavaBuild
原文链接：https://www.cnblogs.com/JavaBuild/p/18203217
体验地址：http://www.jnpfsoft.com/?from=infoq
评论