【Java并发编程】原子操作（二）：四种 Atomic 原子类详析（CAS+自旋）

骑猪看日落 2022-12-09 04:50 173阅读 0赞

在 java.util.concurrent.atomic 包中，一共有12个类，分别是原子更新基本类型，原子更新数组，原子更新引用和原子更新字段。

*  基本类：AtomicInteger、AtomicLong、AtomicBoolean
 *  引用类型：AtomicReference、AtomicReference的ABA实例、 AtomicStampedRerence、AtomicMarkableReference；
 *  数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
 *  属性原子修改器（Updater）：AtomicIntegerFieldUpdater、 AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]  
Atomic 打头的原子操作类，在高并发场景下，都是线程安全的，我们可以放心使用。

> PS：Atomic 包里的类都是基于[魔术类 **Unsafe**][_Unsafe] 去实现的，而最核心的就是 Unsafe\#compareAndSwap~()，即乐观锁 **CAS**。

### 1.原子更新基本类型类 ###

用于通过原子的方式更新基本类型，Atomic包提供了以下三个类：

*  AtomicBoolean：原子更新布尔类型
 *  AtomicInteger：原子更新整型
 *  AtomicLong：原子更新长整型。

我们以 AtomicInteger 为例，来看看它都提供了哪些方法：

public class AtomicInteger extends Number implements java.io.Serializable {
        
        
        // 注:value是被volatile修饰的
        private volatile int value;
    
        // 初始化
        public AtomicInteger(int initialValue) {
        
            value = initialValue;
        }
        
        // 得到当前值
        public final int get() {
        
            return value;
        }
        
        // 自增 1，并返回自增之前的值 
        // 注：自增的底层实现是 CAS+自旋   
        public final int getAndIncrement() {
        
            return unsafe.getAndAddInt(this, valueOffset, 1);
        }
    	
    	// 自增 1，并返回自增之后的值
    	public final int incrementAndGet() {
        
            return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
        }
    	
    	// 将 value 设置成指定值，并返回修改之前的值
    	public final int getAndSet(int newValue) {
        
            return unsafe.getAndSetInt(this, valueOffset, newValue);
        }
        
        // 自减 1，并返回自增之前的值    
        public final int getAndDecrement() {
        
            return unsafe.getAndAddInt(this, valueOffset, -1);
        }
    
    	// 如果 value=expect，那就修改成 update，返回是否能修改
    	public final boolean compareAndSet(int expect, int update) {
        
            return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }
    	
    	// 减同理.....
    	// 增加指定值，并返回增加之前的值
    	public final int getAndAdd(int delta) {
        
            return unsafe.getAndAddInt(this, valueOffset, delta);
        }
    
    }

**问题一**：getAndAddInt() 是如何实现的？

getAndAddInt() 也是 Unsafe 类中的一个方法，源码如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]

可以看到，getAndAddInt() 本质上也是调用 compareAndSwapInt() 来实现的，只不过为了保证增/减操作一定成功，所以使用 do while 来做自旋。

**问题二**：Atomic 包提供了三种基本类型的原子更新，但是Java的基本类型里还有char，float和 double等。那么问题来了，如何原子的更新其他的基本类型呢？

Atomic包里的类基本都是使用Unsafe实现的，**Unsafe只提供了三种CAS方法**（compareAndSwapObject，compareAndSwapInt，compareAndSwapLong），再看AtomicBoolean源码，发现其是先把Boolean转换成整型，再使用 compareAndSwapInt 进行CAS，所以原子更新 double 也可以用类似的思路来实现。

![在这里插入图片描述][20210414201135207.png_pic_center]

### 2.原子更新引用类型类 ###

AtomicInteger 是对 int 类型的值进行自增自减，那如果 Atomic 的对象是个自定义类怎么办呢，Java 也提供了自定义对象的原子操作类，Atomi c包提供了以下三个类：

*  AtomicReference：原子更新引用类型
 *  AtomicReferenceFieldUpdater：原子更新引用类型里的字段
 *  AtomicMarkableReference：原子更新带有标记位的引用类型

我们点开 AtomicReference 可以看到，AtomicReference 类可操作的对象是个泛型，

![在这里插入图片描述][20210414201500741.png_pic_center]  
所以支持自定义类，其底层是没有自增方法的，操作的方法可以作为函数入参传递，源码如下：

// 对 x 执行 accumulatorFunction 操作
    // accumulatorFunction 是个函数，可以自定义想做的事情
    // 返回老值
    public final V getAndAccumulate(V x,BinaryOperator<V> accumulatorFunction) {
        
        // prev 是老值，next 是新值
        V prev, next;
        // 自旋 + CAS 保证一定可以替换老值
        do {
        
            prev = get();
            // 执行自定义操作
            next = accumulatorFunction.apply(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;
    }

### 3.原子更新数组类 ###

通过原子的方式更新数组里的某个元素，Atomic包提供了以下三个类：

*  AtomicIntegerArray：原子更新整型数组里的元素
 *  AtomicLongArray：原子更新长整型数组里的元素
 *  AtomicReferenceArray：原子更新引用类型数组里的元素

AtomicIntegerArray 类主要是提供原子的方式更新数组里的整型，其常用方法如下

*  int addAndGet(int i, int delta)：以原子方式将输入值与数组中索引i的元素相加
 *  boolean compareAndSet(int i, int expect, int update)：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值

### 4.原子更新字段类 ###

如果我们只需要某个类里的某个字段，那么就需要使用原子更新字段类，Atomic包提供了以下三个类：

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

> PS：关于 ABA 问题，这里简单说一下，
> 
> 1.  张三是银行职员，私自挪用了赵四1000元到自己账户
> 2.  张三用这1000去炒股，赚了500元
> 3.  张三赚钱后由将这1000元又转回了李四账户
> 4.  李四查看账户并无发现不妥（但张三实际已经空手套白狼赚了500）

原子更新字段类都是抽象类，每次使用都时候必须使用静态方法newUpdater创建一个更新器。原子更新类的字段的必须使用public volatile修饰符。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/104d357085cd4306a3efd91a9521cdb2.png
[_Unsafe]: https://yzhyaa.blog.csdn.net/article/details/115711244
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/7e6fe6f0212d468eb40a8a60df1bc352.png
[20210414201135207.png_pic_center]: /images/20221123/30fb71fa4c564dfdb414719bb371f835.png
[20210414201500741.png_pic_center]: /images/20221123/b3db82eaea634bc58e18567d3d815f50.png