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

深碍√TFBOYSˉ_ 2022-03-10 06:46 381阅读 0赞

### 文章目录 ###

*   *  1、简介
     *  2、原子更新基本类型
     *   *  2.1、AtomicInteger 实现原子操作的原理
         *   *  2.1.1、AtomicInteger 使用示例
             *  2.1.2、getAndIncrement 源码
         *  2.2、lazySet 方法是如何工作的
         *   *  2.2.1、简介
             *  2.2.2、好处
             *  2.2.3、如何实现
         *  2.3、compareAndSet 与 weakCompareAndSet 区别
     *  3、原子更新数组类型
     *  4、原子更新引用类型
     *  5、原子更新属性类型

## 1、简介 ##

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

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

因为两个线程在更新变量 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][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/][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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]: /images/20220310/c4743b091f47429ebaa2232f7be46694.png
[https_blog.csdn.net_u010647035_article_details_88370551]: https://blog.csdn.net/u010647035/article/details/88370551
[http_ifeve.com_how-does-atomiclong-lazyset-work]: http://ifeve.com/how-does-atomiclong-lazyset-work/