• 26.原子类操作类

    JDK1.5之前，为了保证Java中对单个变量的多个独立操作的原子性和安全性，通常会使用到synchronized锁，但是synchronized需要底层操作系统mutex资源的支持，这是一种重量级资源，性能比较低！  

     JDK1.5的时候，新增了JUC包，增加了许多和同步有关的特性，大大提高了使用Java进行并发编程的效率，比如并发集合、并发队列、新lock锁等。另外，JUC包下面还提供了一个java.util.concurrent.atomic子包，这个atomic包中的类用于在多线程环境下实现单个变量多个独立操作（比如读-写）的连续原子性，并且都比较高效，因为它们都是由基于偏移量（类似于指针）的非阻塞CAS算法实现，用于替代锁的使用。

      JDK1.8的atomic包中具有17个原子类，根据支持的更新变量的类型，我们可以对常用原子类分为三种，分别是原子更新单个变量、原子更新数组、原子更新引用属性（字段）。   atomic 包下的常用原子类如下：

    类摘要
    AtomicBoolean用原子方式更新的 boolean 值。
    AtomicInteger用原子方式更新的 int 值。
    AtomicLong用原子方式更新的 long 值。
    AtomicReference< V >用原子方式更新的对象引用。
    AtomicMarkableReference< V >维护带有boolean标志位的对象引用，可以原子方式对其进行更新。
    AtomicStampedReference< V >维护带有int整数版本号的对象引用，可用原子方式对其进行更新。
    AtomicIntegerArray用原子方式更新其元素的 int 数组。
    AtomicLongArray用原子方式更新其元素的 long 数组。
    AtomicReferenceArray< E >用原子方式更新其元素的对象引用数组。
    AtomicIntegerFieldUpdater< T >基于反射的实用工具，可以对指定类的指定非私有非静态的 volatile int 字段进行原子更新。
    AtomicLongFieldUpdater< T >基于反射的实用工具，可以对指定类的指定非私有非静态的 volatile long 字段进行原子更新。
    AtomicReferenceFieldUpdater< T,V >基于反射的实用工具，可以对指定类的指定非私有非静态的 volatile 引用字段进行原子更新 。
    LongAdderJDK1.8新增加的原子类累加器，使用热点数据分离的思想对long数据进行加法运算，性能更佳！
    LongAccumulatorJDK1.8新增加的原子类累加器，使用热点数据分离的思想对long数据进行指定规则的运算，性能更佳！
    DoubleAdderJDK1.8新增加的原子类累加器，使用热点数据分离的思想对double数据进行加法运算，性能更佳！
    DoubleAccumulatorJDK1.8新增加的原子类累加器，使用热点数据分离的思想对double数据进行指定规则的运算，性能更佳！

    1 原子更新基本类型类

    使用原子的方式更新基本类型，Atomic包提供了以下3个类。

    • AtomicBoolean:原子更新布尔类型。

    • AtomicInteger:原子更新整型。

    • AtomicLong:原子更新长整型。

    以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解， AtomicInteger的常用方法如下。

    • int addAndGet(int delta):以原子方式将输入的数值与实例中的值(AtomicInteger里的 value)相加，并返回结果。

    • boolean compareAndSet(int expect，int update):如果输入的数值等于预期值，则以原子方 式将该值设置为输入的值。

    • int getAndIncrement():以原子方式将当前值加1，注意，这里返回的是自增前的值。

    • void lazySet(int newValue):最终会设置成newValue，使用lazySet设置值后，可能导致其他 线程在之后的一小段时间内还是可以读到旧的值。

    • int getAndSet(int newValue):以原子方式设置为newValue的值，并返回旧值。

    AtomicInteger的使用示例如下：

    1. public class AtomicIntegerTest {
    2.     static AtomicInteger ai = new AtomicInteger(1);
    3.     public static void main(String[] args) {
    4.         System.out.println(ai.getAndIncrement());
    5.         System.out.println(ai.get());
    6.     }
    7. }

    那么getAndIncrement是如何实现原子操作的呢?让我们一起分析其实现原理，getAndIncrement的源码如下所示：

    1. public final int getAndIncrement() {
    2.     return unsafe.getAndAddInt(this, valueOffset, 1);
    3. }

    继续看unsafe的实现：

    1. public final int getAndAddInt(Object var1, long var2, int var4) {
    2.     int var5;
    3.     do {
    4.         var5 = this.getIntVolatile(var1, var2);
    5.     } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    6.  
    7.     return var5;
    8. }

    可以看到这里的本质就是自旋锁，compareAndSwapInt()方法就是Unsafe提供的native那类型的原子更新操作。

    实际上Java中atomic包下的原子类的基石就是：volatile字段修饰符+CAS算法（Unsafe提供）。前面已经对这两个技术进行了深入的讲解。

    通过原子的方式更新单个变量，Atomic包提供了以下4个基础类：

    1. AtomicBoolean：用原子方式更新的 boolean 值。

    2. AtomicInteger：用原子方式更新的 int 值。

    3. AtomicLong：用原子方式更新的 long 值。

    4. AtomicReference< V >：用原子方式更新的对象引用。

     Atomic包实际上只提供了3种基本类型的原子更新：int、long、boolean，其中boolean也是转换为int的0、1进行更新的，实际上并没有char、float和double等的CAS操作，实际上char、 float、double都可以转换为int或者long在进行操作，如果DoubleAdder就是采用Double.doubleToRawLongBits将double转换为long类型的值在进行操作。

    1. /*Unsafe只提供了3种CAS方法.*/
    2. public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    3.  
    4. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    5.  
    6. public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
    7.  
    8. /*AtomicBoolean源码中，它是先把Boolean转换成int类型，再使用compareAndSwapInt进行CAS操作*/
    9. public final boolean compareAndSet(boolean expect, boolean update) {
    10.     int e = expect ? 1 : 0;
    11.     int u = update ? 1 : 0;
    12.     return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    13. }

     上面四个原子类的原理几乎一致，我们后面主要以AtomicInteger来讲解。

    我们看一下Atomiclnteger的源码，其内部有个value属性，它代表了Atomiclnteger 的当前实际取值,所有的方法都是围绕该值进行的。

    1. private volatile int value;
    2.  
    3. public AtomicInteger(int initialValue) {
    4.     value = initialValue;
    5. }
    6.  
    7. public AtomicInteger() {
    8. }
    9.  
    10. /**
    11.  * 内部实际上依赖于Unsafe类的方法，堆value值进行操作
    12.  */
    13. private static final Unsafe unsafe = Unsafe.getUnsafe();
    14. /**
    15.  * value字段的偏移量
    16.  */
    17. private static final long valueOffset;
    18.  
    19. static {
    20.     try {
    21.         //初始化value字段的偏移量
    22.         valueOffset = unsafe.objectFieldOffset
    23.                 (AtomicInteger.class.getDeclaredField("value"));
    24.     } catch (Exception ex) {
    25.         throw new Error(ex);
    26.     }
    27. }

    我们继续看一下get与set相关的几个操作：

    1. public final int get() {
    2.     return value;
    3. }
    4. public final void set(int newValue) {
    5.     value = newValue;
    6. }
    7.  
    8. /**
    9.  * 原子性的将当前值设为给定新值，返回旧值
    10.  * @param newValue 新值
    11.  * @return 旧值
    12.  */
    13. public final int getAndSet(int newValue) {
    14.     return unsafe.getAndSetInt(this, valueOffset, newValue);
    15. }
    16. /**
    17.  * 如果当前值等于预期值，则以原子方式将该值设置为给定的新值
    18.  * @param expect 预期值
    19.  * @param update the new value
    20.  * @return true 更新成功 false 更新失败
    21.  */
    22. public final boolean compareAndSet(int expect, int update) {
    23.     return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    24. }
    25.  
    26. /**
    27.  * 原子性的将当前值加1，返回旧值
    28.  *
    29.  * @return 旧值
    30.  */
    31. public final int getAndIncrement() {
    32.     return unsafe.getAndAddInt(this, valueOffset, 1);
    33. }
    34.  
    35. /**
    36.  * 原子性的将当前值减1，返回旧值
    37.  *
    38.  * @return 返回旧值
    39.  */
    40. public final int getAndDecrement() {
    41.     return unsafe.getAndAddInt(this, valueOffset, -1);
    42. }
    43.  
    44. /**
    45.  * 原子性的将当前值增加delta,返回旧值
    46.  *
    47.  * @param delta 增加的值
    48.  * @return 旧值
    49.  */
    50. public final int getAndAdd(int delta) {
    51.     return unsafe.getAndAddInt(this, valueOffset, delta);
    52. }
    53.  
    54. /**
    55.  * 原子性的将当前值加1，返回新值
    56.  *
    57.  * @return 更新后的值
    58.  */
    59. public final int incrementAndGet() {
    60.     return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    61. }
    62.  
    63. /**
    64.  * 原子性的将当前值减1，返回新值
    65.  *
    66.  * @return 更新后的值
    67.  */
    68. public final int decrementAndGet() {
    69.     return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    70. }
    71.  
    72. /**
    73.  * 原子性的将当前值增加delta，返回新值
    74.  *
    75.  * @param delta 增加的值
    76.  * @return 更新后的值
    77.  */
    78. public final int addAndGet(int delta) {
    79.     return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    80. }
    81.  
    82. /**
    83.  1. 最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
    84.  2. 关于该方法的更多信息可以参考并发编程网翻译的一篇文章《AtomicLong.lazySet是如何工作的？》，文章地址是“http://ifeve.com/how-does-atomiclong-lazyset-work/”。
    85.  3.  4. @param newValue 新值
    86.  */
    87. public final void lazySet(int newValue) {
    88.     unsafe.putOrderedInt(this, valueOffset, newValue);
    89. }

    2 带版本号的原子类

    2.1 原理解析

      通过原子的方式更新单个变量的原子类的升级版，Atomic包提供了以下2个类：

    1. AtomicMarkableReference< V >：维护带有标记位的对象引用，可以原子方式对其进行更新。

    2. AtomicStampedReference< V >：维护带有整数标志的对象引用，可用原子方式对其进行更新。

      上面两个原子类的方法以及原理几乎一致，属于带有版本号的原子类。我们知道CAS操作的三大问题之一就是“ABA”问题：   CAS需要再操作值的时候，检查值有没有发生变化，如果没有发生变化则更新。但是一个值，如果原来为A，变成了B，又变成了A，那么使用CAS进行compare and set的时候，会发现它的值根本没变化过，但实际上是变化过的。   ABA问题的解决思路就是使用版本号，1A->2B->3A，在Atomic包中，提供了一个现成的AtomicStampedReference类来解决ABA问题，使用的就是添加版本号的方法。还有一个AtomicMarkableReference实现类，它比AtomicStampedReference更加简单，AtomicStampedReference中每更新一次数据版本号也会更新一次，这样可以使用版本号统计到底更新了多少次，而AtomicMarkableReference仅仅使用了一个boolean值来表示值是否改变过，因此使用的比较少。   这里我们以AtomicStampedReference来讲解。

    AtomicStampedReference内部不仅维护了我们的传递的对象reference，还维护了一个int类型的版本号stamp，它们都被存放到一个Pair类型的内部类实例中。当AtomicStampedReference 对应的数据被修改时，除了更新数据本身外，还必须要更新版本号，这个版本号一般都是自增的。当AtomicStampedReference 设置对象值时，对象值及版本号都必须满足期望值，才会更新成功。

    1. /**
    2.  * Pair内部类，用于维护reference和stamp
    3.  *
    4.  * @param 
    5.  */
    6. private static class Pair<T> {
    7.     /**
    8.      * 真正的数据
    9.      */
    10.     final T reference;
    11.     /**
    12.      * 版本号
    13.      */
    14.     final int stamp;
    15.  
    16.     private Pair(T reference, int stamp) {
    17.         this.reference = reference;
    18.         this.stamp = stamp;
    19.     }
    20.  
    21.     /**
    22.      * 返回Pair实例
    23.      */
    24.     static <T> Pair<T> of(T reference, int stamp) {
    25.         return new Pair<T>(reference, stamp);
    26.     }
    27. }
    28.  
    29. /**
    30.  * 由于要维护两个属性，因此干脆使用一个内部类对象来维护这两个属性
    31.  */
    32. private volatile Pair<V> pair;
    33.  
    34. /**
    35.  * 创建具有给定初始值的新 AtomicStampedReference。
    36.  *
    37.  * @param initialRef   初始值
    38.  * @param initialStamp 初始版本号
    39.  */
    40. public AtomicStampedReference(V initialRef, int initialStamp) {
    41.     //初始化一个Pair对象，并初始化属性值
    42.     pair = Pair.of(initialRef, initialStamp);
    43. }

    在该类中，最重要的就是compareAndSet方法，它需要传递：期望值、新值、期望版本号、新版本号，当期望值和期望版本号都与此时内部的真实值和真实版本号相等的时候，就会调用compareAndSwapObject使用一个新的Pair对象替换旧的Pair对象，同时完成reference和stamp的更新。

    1. /**
    2.  * 如果当前引用 == 预期引用，并且当前版本号等于预期版本号，则以原子方式将该引用和该标志的值设置为给定的更新值。
    3.  *
    4.  * @param expectedReference 预期引用
    5.  * @param newReference      新引用
    6.  * @param expectedStamp     预期版本号
    7.  * @param newStamp          新版本号
    8.  * @return 如果成功，则返回 true
    9.  */
    10. public boolean compareAndSet(V expectedReference,
    11.                              V newReference,
    12.                              int expectedStamp,
    13.                              int newStamp) {
    14.     Pair<V> current = pair;
    15.     //一系列的判断，如果两个预期值都相等，那么尝试调用compareAndSwapObject使用新的Pair对象替代旧的Pair对象
    16.     //这样就同时完成了reference和stamp的更新
    17.     return
    18.             expectedReference == current.reference &&
    19.                     expectedStamp == current.stamp &&
    20.                     ((newReference == current.reference &&
    21.                             newStamp == current.stamp) ||
    22.                             casPair(current, Pair.of(newReference, newStamp)));
    23. }
    24.  
    25. /**
    26.  * CAS替换内部的Pair对象的方法
    27.  *
    28.  * @param cmp 预期pair对象
    29.  * @param val 新pair对象
    30.  * @return 如果成功，则返回 true
    31.  */
    32. private boolean casPair(Pair<V> cmp, Pair<V> val) {
    33.     return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    34. }
    35.  
    36.  
    37. /**
    38.  * @return 获得当前保存的对象引用
    39.  */
    40. public V getReference() {
    41.     return pair.reference;
    42. }
    43.  
    44. /**
    45.  * @return 获得当前保存的版本号
    46.  */
    47. public int getStamp() {
    48.     return pair.stamp;
    49. }
    50.  
    51. /**
    52.  * 设置新对象引用和版本号
    53.  *
    54.  * @param newReference 新对象引用
    55.  * @param newStamp     新版本号
    56.  */
    57. public void set(V newReference, int newStamp) {
    58.     Pair<V> current = pair;
    59.     //如果新对象引用以及新版本号和之前的都一样那就不设置
    60.     //否则就是新建一个Pair对象并设置相应的属性，替代原来的Pair对象
    61.     if (newReference != current.reference || newStamp != current.stamp)
    62.         this.pair = Pair.of(newReference, newStamp);
    63. }

    2.2 案例分析

    实际上，如果更新的数据是无状态的数据，那么使用基本的原子类也可以完成目的，即如果线程A将值从1->2->1，而线程B仅仅是使用了值，这是没什么问题的，但是如果和业务相关联，比较的对象是有状态的，那么可能会出现严重问题。   比如还是线程A将值从1->2->1，而线程B的业务逻辑是如果发现数据改变过，那么就不能操作，这样的话就不能单纯的比较值了，这就需要用到版本号了。

    1. public class AtomicStampedReferenceDemo {
    2.     public static void main(String args[]) {
    3.         //初始值为0，版本号为0
    4.         AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(0, 0);
    5.  
    6.         Thread thread = new Thread(() -> {
    7.             //先获取标志位
    8.             int timestamp = atomicStampedReference.getStamp();
    9.             //获取原值
    10.             int reference = atomicStampedReference.getReference();
    11.             System.out.println("原值reference: " + reference);
    12.             //阻塞，等待被唤醒
    13.             LockSupport.park();
    14.             if (atomicStampedReference.compareAndSet(reference, reference + 1, timestamp, timestamp + 1)) {
    15.                 System.out.println("更新成功，新值reference: " + atomicStampedReference.getReference());
    16.             } else {
    17.                 System.out.println("更新失败，新值reference: " + atomicStampedReference.getReference());
    18.                 System.out.println("虽然原值和新值相等，但是是在线程阻塞过程中值发生了变化，变化了" + atomicStampedReference.getStamp() + "次");
    19.             }
    20.         });
    21.         thread.start();
    22.  
    23.         Thread thread1 = new Thread(() -> {
    24.             //对数据先加一再减一，反复4次，最终reference的值是不变的
    25.             for (int i = 0; i < 4; i++) {
    26.                 int timestamp = atomicStampedReference.getStamp();
    27.                 int reference = atomicStampedReference.getReference();
    28.                 if (i % 2 == 0) {
    29.                     atomicStampedReference.compareAndSet(reference, reference + 1, timestamp, timestamp + 1);
    30.                 } else {
    31.                     atomicStampedReference.compareAndSet(reference, reference - 1, timestamp, timestamp + 1);
    32.                 }
    33.             }
    34.             //唤醒阻塞的thread线程
    35.             LockSupport.unpark(thread);
    36.         });
    37.         thread1.start();
    38.     }
    39. }

    同样的逻辑，使用普通原子类就能更新成功：

    1. public class AtomicRefrenceDemo {
    2.     public static void main(String args[]) {
    3.         //初始值为0
    4.         AtomicReference<Integer> atomicReference = new AtomicReference<Integer>(0);
    5.  
    6.         Thread thread = new Thread(() -> {
    7.             int reference = atomicReference.get();
    8.             System.out.println("原值reference: " + reference);
    9.             //阻塞，等待被唤醒
    10.             LockSupport.park();
    11.             if (atomicReference.compareAndSet(reference, reference + 1)) {
    12.                 System.out.println("更新成功，新值reference: " + atomicReference.get());
    13.             } else {
    14.                 System.out.println("更新失败，新值reference: " + atomicReference.get());
    15.             }
    16.         });
    17.         thread.start();
    18.  
    19.  
    20.         Thread thread1 = new Thread(() -> {
    21.             //对数据先加一再减一，反复4次，最终的值是不变的
    22.             for (int i = 0; i < 4; i++) {
    23.                 int reference = atomicReference.get();
    24.                 if (i % 2 == 0) {
    25.                     atomicReference.compareAndSet(reference, reference + 1);
    26.                 } else {
    27.                     atomicReference.compareAndSet(reference, reference - 1);
    28.                 }
    29.             }
    30.             //唤醒阻塞的thread线程
    31.             LockSupport.unpark(thread);
    32.         });
    33.         thread1.start();
    34.     }
    35. }

    3 原子更新数组

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

    • AtomicIntegerArray:原子更新整型数组里的元素。

    • AtomicLongArray:原子更新长整型数组里的元素。

    • AtomicReferenceArray:原子更新引用类型数组里的元素。

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

      • int addAndGet(int i，int delta):以原子方式将输入值与数组中索引i的元素相加。

      • boolean compareAndSet(int i，int expect，int update):如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

    以上几个类提供的方法几乎一样，所以本节仅以AtomicIntegerArray为例进行讲解。

    AtomicIntegerArray的使用实例代码

    1. public class AtomicIntegerArrayTest {
    2.     static int[] value = new int[]{1, 2};
    3.     static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    4.     public static void main(String[] args) {
    5.         ai.getAndSet(0, 3);
    6.         System.out.println(ai.get(0));
    7.         System.out.println(value[0]);
    8.     }
    9. }

     接下来我们看一下源码，可以看到内部就是一个int的数组，然后调用Unsafe的方法对数组的元素进行操作。

    1. /**
    2.  * 使用Unsafe操作数组
    3.  */
    4. private static final Unsafe unsafe = Unsafe.getUnsafe();
    5. /**
    6.  * 返回数组类型的第一个元素的偏移地址(基础偏移地址)。
    7.  * 如果arrayIndexScale方法返回的比例因子不为0，你可以通过结合基础偏移地址和比例因子访问数组的所有元素。
    8.  */
    9. private static final int base = unsafe.arrayBaseOffset(int[].class);
    10. /**
    11.  * scale最高位的1的所在位数(从左从0开始)，在计算某个索引的偏移量的时候
    12.  * 使用是该值进行位运算而不是scale进行传统乘法运算，提升效率
    13.  */
    14. private static final int shift;
    15. /**
    16.  * 底层int数组
    17.  */
    18. private final int[] array;
    19.  
    20. static {
    21.     //返回数组单个元素的大小，数组中的元素的地址是连续的，64位虚拟机应该是4
    22.     int scale = unsafe.arrayIndexScale(int[].class);
    23.     //大小必须是2的幂次方
    24.     if ((scale & (scale - 1)) != 0)
    25.         throw new Error("data type scale not a power of two");
    26.     //numberOfLeadingZeros用于返回scale的最高非零位前面的0的个数，包括符号位在内；
    27.     //31减去scale的最高非零位前面的0的个数，就表示scale最高位的1的所在位数，比如scale为2，那么shift为1，如果scale为4，那么shift为2
    28.     shift = 31 - Integer.numberOfLeadingZeros(scale);
    29. }
    30.  
    31. /**
    32.  * 某个数组索引位置的元素的偏移量
    33.  * @param i 数组索引
    34.  * @return 该索引的偏移量
    35.  */
    36. private long checkedByteOffset(int i) {
    37.     if (i < 0 || i >= array.length)
    38.         throw new IndexOutOfBoundsException("index " + i);
    39.     return byteOffset(i);
    40. }
    41.  
    42. /**
    43.  * @param i 索引位置
    44.  * @return 返回某个数组索引位置的元素的偏移量
    45.  */
    46. private static long byteOffset(int i) {
    47.     //这里就能明白shift的作用了，对于2的幂次方的scale：
    48.     //这里可以使用scale的最高为1的位置shift的位运算i << shift，代替scale*i的传统运算，效率提高
    49. //比如scale=4，那么shift=2，如果i=3，那么i<<shift = 3 << 2 = 12 就等于 scale*i = 4 * 3  = 12
    50. //比如scale=8，那么shift=3，如果i=3，那么i<<shift = 3 << 3 = 24 就等于 scale*i = 8 * 3  = 24
    51.     return ((long) i << shift) + base;
    52. }
    53.  
    54.  
    55. /**
    56.  * 创建给定长度的新 AtomicIntegerArray。
    57.  * @param length 给定长度
    58.  */
    59. public AtomicIntegerArray(int length) {
    60.     array = new int[length];
    61. }
    62.  
    63. /**
    64.  * 创建与给定数组具有相同长度的新 AtomicIntegerArray，并从给定数组复制其所有元素。
    65.  *
    66.  * @param array 给定数组
    67.  * @throws NullPointerException 如果数组为 null
    68.  */
    69. public AtomicIntegerArray(int[] array) {
    70.     // 克隆数组，元素浅克隆
    71.     this.array = array.clone();
    72. }

    其常用方法如下，基于Unsafe的volatile和CAS操作：

    1. /**
    2.  * 获取i索引位置的当前值
    3.  * @param i 多赢
    4.  * @return 当前值
    5.  */
    6. public final int get(int i) {
    7.     return getRaw(checkedByteOffset(i));
    8. }
    9.  
    10. private int getRaw(long offset) {
    11.     //volatile的获取最新值
    12.     return unsafe.getIntVolatile(array, offset);
    13. }
    14.  
    15. /**
    16.  * 在i索引位置设定为指定新值
    17.  * @param i        索引
    18.  * @param newValue 新值
    19.  */
    20. public final void set(int i, int newValue) {
    21.     //volatile的写
    22.     unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);
    23. }
    24.  
    25. /**
    26.  * 以原子方式将元素设置在i索引位置，并返回旧值
    27.  * @param i        索引
    28.  * @param newValue 新值
    29.  * @return 旧值
    30.  */
    31. public final int getAndSet(int i, int newValue) {
    32.     return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);
    33. }
    34.  
    35. /**
    36.  * 以原子方式将输入值与数组中索引i的元素相加，并返回旧值
    37.  * @param i     索引
    38.  * @param delta 相加的数据
    39.  * @return 旧值
    40.  */
    41. public final int getAndAdd(int i, int delta) {
    42.     return unsafe.getAndAddInt(array, checkedByteOffset(i), delta);
    43. }
    44.  
    45. /**
    46.  * 以原子方式将输入值与数组中索引i的元素相加，并返回新值
    47.  * @param i     索引
    48.  * @param delta 相加的数据
    49.  * @return 更新后的值
    50.  */
    51. public final int addAndGet(int i, int delta) {
    52.     return getAndAdd(i, delta) + delta;
    53. }
    54.  
    55. /**
    56.  1. 如果当前值等于预期值，则以原子方式将数组位置i的元素设置成新值。
    57.  2.  3. @param i      索引
    58.  3. @param expect 预期值
    59.  4. @param update 新值
    60.  5. @return true表示CAS成功 false 表示CAS失败
    61.  */
    62. public final boolean compareAndSet(int i, int expect, int update) {
    63.     return compareAndSetRaw(checkedByteOffset(i), expect, update);
    64. }

    4 原子更新引用类型

    原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类。

    • AtomicReference:原子更新引用类型。

    • AtomicReferenceFieldUpdater:原子更新引用类型里的字段。

    • AtomicMarkableReference:原子更新带有标记位的引用类型。可以原子更新一个布尔类 型的标记位和引用类型。构造方法是AtomicMarkableReference(V initialRef，boolean initialMark)。

    以上几个类提供的方法几乎一样，所以本节仅以AtomicReference为例进行讲解。AtomicIntegerFieldUpdater实际上是一个抽象类，它的实现类实际上在它的内部而且是私有的，因此只能使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性字符串名。   另外，这里对于对象的字段的设置是先采用getDeclaredField方法反射获取的对应字段的Filed对象，然后在对Filed对象进行操作，并且没有设置setAccessible权限，因此类的字段属性不能是私有属性！   由于CAS 操作会通过对象实例中的偏移量直接进行赋值，即Unsafe. objectFieldOffset()方法。因此，它不支持对static属性的赋值。   对象的字段还应该被设置为volatile类型，这样就能获取到最新的值。

    AtomicReference的使用示例代码如下

    1. public class AtomicFieldUpdaterTest {
    2.     public static void main(String[] args) {
    3.         AtomicIntegerFieldUpdater old = AtomicIntegerFieldUpdater.newUpdater(User.class, "old");
    4.         AtomicReferenceFieldUpdater name = AtomicReferenceFieldUpdater.newUpdater(User.class, String.class, "name");
    5.  
    6.         User user = new User("user", 10);
    7.  
    8.         System.out.println(old.getAndIncrement(user));
    9.         System.out.println(old.get(user));
    10.  
    11.         System.out.println(name.getAndSet(user, "user2"));
    12.         System.out.println(name.get(user));
    13.     }
    14.  
    15.     public static class User {
    16.         volatile String name;
    17.         volatile int old;
    18.  
    19.         User(String name, int old) {
    20.             this.name = name;
    21.             this.old = old;
    22.         }
    23.  
    24.         public String getName() {
    25.             return name;
    26.         }
    27.  
    28.         public int getOld() {
    29.             return old;
    30.         }
    31.     }
    32. }

    代码中首先构建一个user对象，然后把user对象设置进AtomicReferenc中，最后调用 compareAndSet方法进行原子更新操作，实现原理同AtomicInteger里的compareAndSet方法。

  • 相关阅读:
    容联云入选IDC生成式AI图谱，多个案例被评典型应用
    在 msys2/mingw 下安装及编译 opencv
    2023-IDEA插件推荐
    获取Spring中@PathVariable注解里带点的完整参数
    AcWing 836. 合并集合 —— 递推递归一起食用效果更佳哦~
    第三章《数组与循环》第3节：while循环
    【深入浅出React和Redux】读书笔记二:设计高质量的React组件
    .balckhoues-V-XXXXXXX勒索病毒数据怎么处理|数据解密恢复
    （附源码）spring boot大学英语智慧教学平台 毕业设计 201722
    【2014NOIP普及组】T4:子矩阵 试题解析
  • 原文地址：https://blog.csdn.net/xueyushenzhou/article/details/127038744