• JUC学习笔记——共享模型之无锁

    在本系列内容中我们会对JUC做一个系统的学习，本片将会介绍JUC的无锁

    我们会分为以下几部分进行介绍：

    • 无锁操作
    • CAS与Volatile
    • 原子类型
    • 原理篇
    • Unsafe

    并发无锁操作

    这一小节我们将讲解如何用无锁操作完成并发操作

    问题展现

    我们给出一段之前并发展示代码：

    1. /*并发代码*/
    2.  
    3. package cn.itcast;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6. interface Account {
    7.     // 获取余额
    8.     Integer getBalance();
    9.     // 取款
    10.     void withdraw(Integer amount);
    11.     /**
    12.  * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
    13.  * 如果初始余额为 10000 那么正确的结果应当是 0
    14.  */
    15.     static void demo(Account account) {
    16.         List<Thread> ts = new ArrayList<>();
    17.         long start = System.nanoTime();
    18.         for (int i = 0; i < 1000; i++) {
    19.             ts.add(new Thread(() -> {
    20.                 account.withdraw(10);
    21.             }));
    22.         }
    23.         ts.forEach(Thread::start);
    24.         ts.forEach(t -> {
    25.             try {
    26.                 t.join();
    27.             } catch (InterruptedException e) {
    28.                 e.printStackTrace();
    29.             }
    30.         });
    31.         long end = System.nanoTime();
    32.         System.out.println(account.getBalance() 
    33.                            + " cost: " + (end-start)/1000_000 + " ms");
    34.     }
    35. }
    36.  
    37. /*主代码*/
    38. public static void main(String[] args) {
    39.     Account.demo(new AccountUnsafe(10000));
    40. }
    41.  
    42. /*输出结果*/
    43. 330 cost: 306 ms

    解决并发问题（锁）

    我们在之前已经学习过了锁的基本操作，并且可以解决并发问题：

    1. /*并发代码*/
    2.  
    3. // 给 Account 对象加锁
    4. class AccountUnsafe implements Account {
    5.     private Integer balance;
    6.     public AccountUnsafe(Integer balance) {
    7.         this.balance = balance;
    8.     }
    9.     @Override
    10.     public synchronized Integer getBalance() {
    11.         return balance;
    12.     }
    13.     @Override
    14.     public synchronized void withdraw(Integer amount) {
    15.         balance -= amount;
    16.     }
    17. }
    18.  
    19. /*主代码*/
    20. public static void main(String[] args) {
    21.     Account.demo(new AccountUnsafe(10000));
    22. }
    23.  
    24. /*输出结果*/
    25. 0 cost: 399 ms

    解决并发问题（无锁）

    JDK为我们提供了几种乐观锁的无锁并发问题解决类型：

    1. /*解释*/
    2. AtomicInteger：原子int类型，属于实现类，传入一个integer类型的参数，可以调用其内部方法对其改变
    3. AtomicInteger内部有一个value值，该值会存放你传入的Integer参数，其所有方法都是对该值进行改变或获得！
    4.  
    5. /*并发代码*/
    6. class AccountSafe implements Account {
    7.     // 定义共享数据为乐观锁AtomicInteger类型
    8.     private AtomicInteger balance;
    9.     
    10.     // 构造方法，在创建类时，将传入的参数创建为AtomicInteger类型并赋值
    11.     public AccountSafe(Integer balance) {
    12.         this.balance = new AtomicInteger(balance);
    13.     }
    14.     
    15.     // 获得：调用AtomicInteger类型的get方法
    16.     @Override
    17.     public Integer getBalance() {
    18.         return balance.get();
    19.     }
    20.     
    21.     // 改变：amount为值
    22.     @Override
    23.     public void withdraw(Integer amount) {
    24.         // 一直进行直到完成操作
    25.         while (true) {
    26.             // 记录修改前的值和修改后的值
    27.             int prev = balance.get();
    28.             int next = prev - amount;
    29.             // 采用compareAndSet，首先对比当前值是否为prev，如果是将该值修改为next，并返回true
    30.             if (balance.compareAndSet(prev, next)) {
    31.                 // 执行成功，退出循环！
    32.                 break;
    33.             }
    34.         }
    35.         // 可以简化为下面的方法
    36.         // balance.addAndGet(-1 * amount);
    37.     }
    38. }
    39.  
    40. /*主代码*/
    41. public static void main(String[] args) {
    42.     Account.demo(new AccountSafe(10000));
    43. }
    44.  
    45. /*运行结果*/
    46. 0 cost: 302 ms
    47.     
    48. /*补充说明*/
    49. 乐观锁并没有运用锁，它采用的是不断运行，如果可以执行就执行，如果不可以执行就一直运行直到执行成功！

    CAS 与 volatile

    这一小节我们将讲解无锁操作中的CAS和Volatile相关内容

    CAS简述

    首先我们介绍一下CAS：

    • compareAndSet，它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作。

    此外我们还需要知道CAS本身就是原子操作：

    • 其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。

    • 在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再 开启总线。

    • 这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的。

    我们给出一张CAS操作的展示图：

    Volatile

    我们在之前已经详细的介绍了Volatile的内容：

    • Volatile可以保证该数据元素的可见性以及有序性
    • 获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。
    • 他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。
    • 即一个线程对 volatile 变量的修改，对另一个线程可见。

    CAS必须搭配Volatile共同使用：

    • CAS 必须借助volatile才能读取到共享变量的最新值来实现【比较并交换】的效果。

    CAS特点

    我们来简单介绍一下CAS的特点：

    • 结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。
    • CAS 体现的是无锁并发、无阻塞并发
    • 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
    • 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

    我们反观Synchronized的特点：

    • synchronized 是基于悲观锁的思想：
    • 最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。

    因而我们其实可以很清楚的明白无锁操作是要比锁操作速度要快的：

    • 无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，类似于自旋。而 synchronized 会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。线程的上下文切换是费时的，在重试次数不是太多时，无锁的效率高于有锁。
    • 线程就好像高速跑道上的赛车，高速运行时，速度超快，一旦发生上下文切换，就好比赛车要减速、熄火， 等被唤醒又得重新打火、启动、加速... 恢复到高速运行，代价比较大

    但是也有特殊状况：

    • 但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。
    • 所以总的来说，当线程数小于等于cpu核心数时，使用无锁方案是很合适的，因为有足够多的cpu让线程运行。
    • 当线程数远多于cpu核心数时，无锁效率相比于有锁就没有太大优势，因为依旧会发生上下文切换。

    原子类型

    这一小节我们将讲解无锁操作中的各种原子类型

    原子整数

    首先我们来介绍一下原子整数，大致分为三类：

    • AtomicBoolean
    • AtomicInteger
    • AtomicLong

    由于三种原子整数相似，我们仅给出一种实例：

    1. /*原子整数型介绍*/
    2.  
    3. - AtomicBoolean：布尔类型的原子整数
    4. - AtomicInteger：int类型的原子整数
    5. - AtomicLong：Long类型的原子整数
    6.     
    7. /*相关方法展示*/
    8.     
    9. // 首先创建一个AtomicInteger类型
    10. AtomicInteger i = new AtomicInteger(0);
    11.  
    12. // 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
    13. System.out.println(i.getAndIncrement());
    14.  
    15. // 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
    16. System.out.println(i.incrementAndGet());
    17.  
    18. // 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
    19. System.out.println(i.decrementAndGet());
    20.  
    21. // 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
    22. System.out.println(i.getAndDecrement());
    23.  
    24. // 获取并加值（i = 0, 结果 i = 5, 返回 0）
    25. System.out.println(i.getAndAdd(5));
    26.  
    27. // 加值并获取（i = 5, 结果 i = 0, 返回 0）
    28. System.out.println(i.addAndGet(-5));
    29.  
    30. // 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
    31. // 其中函数中的操作能保证原子，但函数需要无副作用
    32. System.out.println(i.getAndUpdate(p -> p - 2));
    33.  
    34. // 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
    35. // 其中函数中的操作能保证原子，但函数需要无副作用
    36. System.out.println(i.updateAndGet(p -> p + 2));
    37.  
    38. // 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
    39. // 其中函数中的操作能保证原子，但函数需要无副作用
    40. // getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
    41. // getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
    42. System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
    43.  
    44. // 计算并获取（i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0）
    45. // 其中函数中的操作能保证原子，但函数需要无副作用
    46. System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
    47.  
    48. /*相关知识补充*/
    49.  
    50. getAndUpdate,updateAndGet,getAndAccumulate,accumulateAndGet所需的参数都是IntUnaryOperator类型
    51.  
    52. 该类型只有一个抽象方法，其需要输入int类型，会返回类型，我们只需要采用Lambda表达式重新构造即可使用！
    53.  
    54. /*源码展示*/
    55.  
    56. // 以上方法都是以CAS为基础进行了封装，保证了方法的原子性和变量的可见性。
    57.  
    58. // 我们调其中一个方法进行底层代码的剖析：
    59. public static int updateAndGet(AtomicInteger i, IntUnaryOperator operator){
    60.     while (true){
    61.         int prev = i.get();
    62.         int next = operator.applyAsInt(prev);
    63.         if(i.compareAndSet(prev,next)){
    64.             return next;
    65.         }
    66.     }
    67. }

    原子引用

    我们的原子引用主要分为三类：

    • AtomicReference
    • AtomicMarkableReference
    • AtomicStampedReference

    我们针对三种不同的原子引用类型展开讲解：

    1. /*基本解释*/
    2.  
    3. - AtomicReference ：最基本的原子引用，引用对象后，针对其方法进行改变即可
    4. - AtomicMarkableReference ：在AtomicReference的基础上，多了一个版本号，用来检测当前版本与当时未修改前的版本的差距
    5. - AtomicStampedReference ：在AtomicReference的基础上，多一个判断，用来判断该对象是否被修改
    6.     
    7. /*不安全版本*/
    8.     
    9. class DecimalAccountUnsafe implements DecimalAccount {
    10.     
    11.     BigDecimal balance;
    12.         
    13.     public DecimalAccountUnsafe(BigDecimal balance) {
    14.         this.balance = balance;
    15.     }
    16.     
    17.     @Override
    18.     public BigDecimal getBalance() {
    19.         return balance;
    20.     }
    21.     
    22.     @Override
    23.     public void withdraw(BigDecimal amount) {
    24.         BigDecimal balance = this.getBalance();
    25.         this.balance = balance.subtract(amount);
    26.     }
    27. }    
    28.  
    29. /*锁*/
    30.  
    31. class DecimalAccountSafeLock implements DecimalAccount {
    32.     
    33.     private final Object lock = new Object();
    34.     
    35.     BigDecimal balance;
    36.     
    37.     public DecimalAccountSafeLock(BigDecimal balance) {
    38.         this.balance = balance;
    39.     }
    40.     
    41.     @Override
    42.     public BigDecimal getBalance() {
    43.         return balance;
    44.     }
    45.     
    46.     @Override
    47.     public void withdraw(BigDecimal amount) {
    48.         synchronized (lock) {
    49.             BigDecimal balance = this.getBalance();
    50.             this.balance = balance.subtract(amount);
    51.         }
    52.     }
    53. }
    54.  
    55. /*AtomicReference*/
    56.  
    57. class DecimalAccountSafeCas implements DecimalAccount {
    58.     
    59.     // 我们并不是直接获得对象本身，而是采用一个AtomicReference类进行包装，里面装的是BigDecimal类型的value值
    60.     // 同样我们后续的操作都是针对这个value值操作
    61.     AtomicReference<BigDecimal> ref;
    62.     
    63.     // 初始化进行赋值
    64.     public DecimalAccountSafeCas(BigDecimal balance) {
    65.         ref = new AtomicReference<>(balance);
    66.     }
    67.     
    68.     // 得到value值
    69.     @Override
    70.     public BigDecimal getBalance() {
    71.         return ref.get();
    72.     }
    73.     
    74.     // 采用compareAndSet方法对value值进行判断并修改
    75.     // 但这时我们只能根据其prev来进行判断，prev和当前值相同，改为next；若不同不修改；无法判断内部是否经过改变
    76.     // 比如，最开始为a，后面有一个线程a->b,又出现一个线程b->a，当然我们当前线程就会默认没有发生变化而直接改变为next目标值
    77.     @Override
    78.     public void withdraw(BigDecimal amount) {
    79.         while (true) {
    80.             BigDecimal prev = ref.get();
    81.             BigDecimal next = prev.subtract(amount);
    82.             if (ref.compareAndSet(prev, next)) {
    83.                 break;
    84.             }
    85.         }
    86.     }
    87. }
    88.  
    89. /*AtomicMarkableReference */
    90.  
    91. // 模拟操作
    92. @Slf4j
    93. public class TestABAAtomicMarkableReference {
    94.     public static void main(String[] args) throws InterruptedException {
    95.         
    96.         // 首先创建一个垃圾袋装满垃圾
    97.         GarbageBag bag = new GarbageBag("装满了垃圾");
    98.         
    99.         // 我们采用AtomicMarkableReference封装对象，对象为垃圾袋；参数2 mark 可以看作一个标记，表示垃圾袋满了
    100.         AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
    101.         
    102.         // 开始操作（打印当前状况）
    103.         log.debug("主线程 start...");
    104.         GarbageBag prev = ref.getReference();
    105.         log.debug(prev.toString());
    106.         
    107.         // 该线程负责打扫垃圾，这时我们会调用AtomicMarkableReference的compareAndSet方法
    108.         // 里面不仅包含了value的prev和next还包含了mark的prev和next
    109.         new Thread(() -> {
    110.             log.debug("打扫卫生的线程 start...");
    111.             bag.setDesc("空垃圾袋");
    112.             while (!ref.compareAndSet(bag, bag, true, false)) {}
    113.             log.debug(bag.toString());
    114.         }).start();
    115.         
    116.         // 在前面的线程修改之后，我们如果还想判断修改，这时需要prev为true，但已经改变为false，所以不会执行
    117.         Thread.sleep(1000);
    118.         log.debug("主线程想换一只新垃圾袋？");
    119.         boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
    120.         log.debug("换了么？" + success);
    121.         log.debug(ref.getReference().toString());
    122.     }
    123. }
    124.  
    125. // 模拟垃圾袋
    126. class GarbageBag {
    127.     String desc;
    128.     public GarbageBag(String desc) {
    129.         this.desc = desc;
    130.     }
    131.     public void setDesc(String desc) {
    132.         this.desc = desc;
    133.     }
    134.     @Override
    135.     public String toString() {
    136.         return super.toString() + " " + desc;
    137.     }
    138. }
    139.  
    140. // 结果展示
    141. 2019-10-13 15:30:09.264 [main] 主线程 start... 
    142. 2019-10-13 15:30:09.270 [main] cn.itcast.GarbageBag@5f0fd5a0 装满了垃圾
    143. 2019-10-13 15:30:09.293 [Thread-1] 打扫卫生的线程 start... 
    144. 2019-10-13 15:30:09.294 [Thread-1] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋
    145. 2019-10-13 15:30:10.294 [main] 主线程想换一只新垃圾袋？
    146. 2019-10-13 15:30:10.294 [main] 换了么？false 
    147. 2019-10-13 15:30:10.294 [main] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋
    148.     
    149. /*AtomicStampedReference */
    150.     
    151. // 代码展示
    152.     
    153. // 我们同样采用AtomicStampedReference来装载对象，但是AtomicStampedReference会多一个版本号
    154. // 该版本号可以进行++修改，这样我们就可以得知我们进行了几次修改
    155. static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
    156.  
    157. public static void main(String[] args) throws InterruptedException {
    158.     log.debug("main start...");
    159.     // 获取值 A
    160.     String prev = ref.getReference();
    161.     // 获取版本号
    162.     int stamp = ref.getStamp();
    163.     log.debug("版本 {}", stamp);
    164.     // 如果中间有其它线程干扰，发生了 ABA 现象
    165.     other();
    166.     sleep(1);
    167.     // 尝试改为 C
    168.     log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
    169. }
    170.  
    171. private static void other() {
    172.     
    173.     new Thread(() -> {
    174.         log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", 
    175.                                                       ref.getStamp(), ref.getStamp() + 1));
    176.         log.debug("更新版本为 {}", ref.getStamp());
    177.     }, "t1").start();
    178.     
    179.     sleep(0.5);
    180.     
    181.     new Thread(() -> {
    182.         log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", 
    183.                                                       ref.getStamp(), ref.getStamp() + 1));
    184.         log.debug("更新版本为 {}", ref.getStamp());
    185.     }, "t2").start();
    186.     
    187. }
    188.  
    189. // 结果展示
    190. 15:41:34.891 c.Test36 [main] - main start... 
    191. 15:41:34.894 c.Test36 [main] - 版本 0 
    192. 15:41:34.956 c.Test36 [t1] - change A->B true 
    193. 15:41:34.956 c.Test36 [t1] - 更新版本为 1 
    194. 15:41:35.457 c.Test36 [t2] - change B->A true 
    195. 15:41:35.457 c.Test36 [t2] - 更新版本为 2 
    196. 15:41:36.457 c.Test36 [main] - change A->C false

    原子数组

    我们的原子引用主要分为三类：

    • AtomicIntegerArray
    • AtomicLongArray
    • AtomicReferenceArray

    这三种数组除了内部包含的元素不同外基本相同，所以我们仅介绍一种：

    1. /*lambda知识点补充*/
    2.  
    3. 我们将Lambda里面的类型分为三种类型：
    4.  
    5. supplier 提供者 无中生有 ()->结果
    6. function 函数 一个参数一个结果 (参数)->结果；BiFunction (参数1,参数2)->结果
    7. consumer 消费者 一个参数没结果 (参数)->void；BiConsumer (参数1,参数2)->void
    8.     
    9. /*统一数组处理机制*/
    10.     
    11. // 我们给出一套Lambda方法处理数组的Demo函数来进行检测
    12.     
    13.  // 参数1，提供数组、可以是线程不安全数组或线程安全数组
    14.  // 参数2，获取数组长度的方法
    15.  // 参数3，自增方法，回传 array, index
    16.  // 参数4，打印数组的方法
    17.     
    18. private static <T> void demo(
    19.     Supplier<T> arraySupplier,
    20.     Function<T, Integer> lengthFun,
    21.     BiConsumer<T, Integer> putConsumer,
    22.     Consumer<T> printConsumer ) {
    23.     List<Thread> ts = new ArrayList<>();
    24.     T array = arraySupplier.get();
    25.     int length = lengthFun.apply(array);
    26.     for (int i = 0; i < length; i++) {
    27.         // 每个线程对数组作 10000 次操作
    28.         ts.add(new Thread(() -> {
    29.             for (int j = 0; j < 10000; j++) {
    30.                 putConsumer.accept(array, j%length);
    31.             }
    32.         }));
    33.     }
    34.     ts.forEach(t -> t.start()); // 启动所有线程
    35.     ts.forEach(t -> {
    36.         try {
    37.             t.join();
    38.         } catch (InterruptedException e) {
    39.             e.printStackTrace();
    40.         }
    41.     }); // 等所有线程结束
    42.     printConsumer.accept(array);
    43. }
    44.  
    45. /*不安全数组*/
    46.  
    47. // 代码
    48. demo(
    49.     ()->new int[10],
    50.     (array)->array.length,
    51.     (array, index) -> array[index]++,
    52.     array-> System.out.println(Arrays.toString(array))
    53. );
    54.  
    55. // 结果
    56. [9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698] 
    57.  
    58. /*安全数组：大部分方法和原子整数以及原子引用完全相同*/
    59.  
    60. // 代码
    61. demo(
    62.     ()-> new AtomicIntegerArray(10),
    63.     (array) -> array.length(),
    64.     (array, index) -> array.getAndIncrement(index),
    65.     array -> System.out.println(array)
    66. );
    67.  
    68. // 结果
    69. [10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

    字段更新器

    我们首先来介绍一下字段更新器：

    • 利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常

    我们的字段更新器通常分为三种：

    • AtomicIntegerFieldUpdater
    • AtomicLongFieldUpdater
    • AtomicReferenceFieldUpdater

    我们来进行代码展示：

    1. /*代码展示*/
    2.  
    3. public class Test5 {
    4.     
    5.     // 在该类中设置字段
    6.     private volatile int field;
    7.     
    8.     public static void main(String[] args) {
    9.         
    10.         // 创建字段更新器，前面为类名.class,后面为属性名
    11.         AtomicIntegerFieldUpdater fieldUpdater =
    12.             AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");
    13.         
    14.         // 我们需创建一个对象，作为字段更新器的类对象
    15.         Test5 test5 = new Test5();
    16.         
    17.         // 修改0->10
    18.         fieldUpdater.compareAndSet(test5, 0, 10);
    19.         System.out.println(test5.field);
    20.         
    21.         // 修改10->20
    22.         fieldUpdater.compareAndSet(test5, 10, 20);
    23.         System.out.println(test5.field);
    24.         
    25.         // 修改10->30，修改失败！
    26.         fieldUpdater.compareAndSet(test5, 10, 30);
    27.         System.out.println(test5.field);
    28.     }
    29. }
    30.  
    31. /*结果展示*/
    32. 10 
    33. 20 
    34. 20

    原子累加器

    CAS专门创建了一种原子累加器，其由于性能远高于正常CAS，固被留下使用：

    • LongAdder
    • 性能提升的原因很简单，在有竞争时，设置多个累加单元，Therad-0 累加 Cell[0]，而 Thread-1 累加 Cell[1]... 最后将结果汇总。
    • 这样它们在累加时操作的不同的 Cell 变量，因此减少了CAS 重试失败，从而提高性能。

    我们采用代码进行比对：

    1. /*主代码*/
    2.  
    3. // 原子累加器
    4. for (int i = 0; i < 5; i++) {
    5.     demo(() -> new LongAdder(), adder -> adder.increment());
    6. }
    7. // 正常CAS操作
    8. for (int i = 0; i < 5; i++) {
    9.     demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
    10. }
    11.  
    12. /*测试函数*/
    13.  
    14. private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
    15.     T adder = adderSupplier.get();
    16.     long start = System.nanoTime();
    17.     List<Thread> ts = new ArrayList<>();
    18.     // 4 个线程，每人累加 50 万
    19.     for (int i = 0; i < 40; i++) {
    20.         ts.add(new Thread(() -> {
    21.             for (int j = 0; j < 500000; j++) {
    22.                 action.accept(adder);
    23.             }
    24.         }));
    25.     }
    26.     ts.forEach(t -> t.start());
    27.     ts.forEach(t -> {
    28.         try {
    29.             t.join();
    30.         } catch (InterruptedException e) {
    31.             e.printStackTrace();
    32.         }
    33.     });
    34.     long end = System.nanoTime();
    35.     System.out.println(adder + " cost:" + (end - start)/1000_000);
    36. }
    37.  
    38. /*结果对比*/
    39.  
    40. 1000000 cost:43 
    41. 1000000 cost:9 
    42. 1000000 cost:7 
    43. 1000000 cost:7 
    44. 1000000 cost:7 
    45. 1000000 cost:31 
    46. 1000000 cost:27 
    47. 1000000 cost:28 
    48. 1000000 cost:24 
    49. 1000000 cost:22

    原理篇

    这一小节我们将讲解无锁操作中的一些原理内容

    LongAdder组成

    首先我们给出LongAdder组成部分：

    1. /*LongAdder组成*/
    2.  
    3. // 累加单元数组, 懒惰初始化
    4. transient volatile Cell[] cells;
    5.  
    6. // 基础值, 如果没有竞争, 则用 cas 累加这个域
    7. transient volatile long base;
    8.  
    9. // 在 cells 创建或扩容时, 置为 1, 表示加锁
    10. transient volatile int cellsBusy;
    11.  
    12. /*Cell组成*/
    13.  
    14. // 防止缓存行伪共享
    15. @sun.misc.Contended
    16. static final class Cell {
    17.     
    18.     volatile long value;
    19.     
    20.     Cell(long x) { value = x; }
    21.  
    22.     // 最重要的方法, 用来 cas 方式进行累加, prev 表示旧值, next 表示新值
    23.     final boolean cas(long prev, long next) {
    24.         return UNSAFE.compareAndSwapLong(this, valueOffset, prev, next);
    25.     }
    26.     // 省略不重要代码
    27. }

    LongAdder加锁设置

    我们可以看到这里的是否创建cell采用的是一种CAS锁的机制，我们这里简单介绍一下：

    1. package cn.itcast.test;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4.  
    5. import java.util.concurrent.atomic.AtomicInteger;
    6.  
    7. import static cn.itcast.n2.util.Sleeper.sleep;
    8.  
    9. @Slf4j(topic = "c.Test42")
    10. public class LockCas {
    11.     // 0 没加锁
    12.     // 1 加锁
    13.     private AtomicInteger state = new AtomicInteger(0);
    14.  
    15.     public void lock() {
    16.         while (true) {
    17.             if (state.compareAndSet(0, 1)) {
    18.                 break;
    19.             }
    20.         }
    21.     }
    22.  
    23.     public void unlock() {
    24.         log.debug("unlock...");
    25.         state.set(0);
    26.     }
    27.  
    28.     public static void main(String[] args) {
    29.         LockCas lock = new LockCas();
    30.         new Thread(() -> {
    31.             log.debug("begin...");
    32.             lock.lock();
    33.             try {
    34.                 log.debug("lock...");
    35.                 sleep(1);
    36.             } finally {
    37.                 lock.unlock();
    38.             }
    39.         }).start();
    40.  
    41.         new Thread(() -> {
    42.             log.debug("begin...");
    43.             lock.lock();
    44.             try {
    45.                 log.debug("lock...");
    46.             } finally {
    47.                 lock.unlock();
    48.             }
    49.         }).start();
    50.     }
    51. }

    LongAdder伪共享

    我们在Cell的类代码中可以看到这个注解：

    • @sun.misc.Contended:防止缓存行伪共享

    首先我们知道内存之上还有缓存，其速度是具有极大差距的：

    从 cpu 到大约需要的时钟周期
    寄存器1 cycle (4GHz 的 CPU 约为0.25ns)
    L13~4 cycle
    L210~20 cycle
    L340~45 cycle
    内存120~240 cycle

    缓存的加入会造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中

    同时CPU 要保证数据的一致性，如果某个 CPU 核心更改了数据，其它 CPU 核心对应的整个缓存行必须失效

    我们给出简单示例图：

    所以如果我们想要实现CAS的多处理器直接操作最后相加的想法就需要使缓存的这个特性变化：

    因而我们就采用注解的方法：

    • @sun.misc.Contended 用来解决这个问题
    • 它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的padding，
    • 从而让 CPU 将对象预读至缓存时占用不同的缓存行，这样不会造成对方缓存行的失效

    Unsafe

    这一小节我们将讲解Unsafe类

    Unsafe概述

    我们首先来简单介绍一下Unsafe：

    • Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得
    • jdk8直接调用Unsafe.getUnsafe()获得的unsafe不能用。

    我们给出简单例子展示：

    1. /*获得Unsafe*/
    2.  
    3. public class UnsafeAccessor {
    4.     static Unsafe unsafe;
    5.     static {
    6.         try { 
    7.             Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
    8.             theUnsafe.setAccessible(true);
    9.             unsafe = (Unsafe) theUnsafe.get(null);
    10.         } catch (NoSuchFieldException | IllegalAccessException e) {
    11.             throw new Error(e);
    12.         }
    13.     }
    14.     static Unsafe getUnsafe() {
    15.         return unsafe;
    16.     }
    17. }
    18.  
    19. /*unsafe使用（会操作底层内存等数据，尽量不要使用）*/
    20.  
    21. //以下三个方法只执行一次，成功返回true，不成功返回false
    22. public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    23.  
    24. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    25.  
    26. public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
    27.  
    28. //以下方法都是在以上三个方法的基础上进行封装，会循环直到成功为止。
    29. public final int getAndAddInt(Object var1, long var2, int var4) {
    30.     int var5;
    31.     do {
    32.         var5 = this.getIntVolatile(var1, var2);
    33.     } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    34.  
    35.     return var5;
    36. }
    37.  
    38. public final long getAndAddLong(Object var1, long var2, long var4) {
    39.     long var6;
    40.     do {
    41.         var6 = this.getLongVolatile(var1, var2);
    42.     } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
    43.  
    44.     return var6;
    45. }
    46.  
    47. public final int getAndSetInt(Object var1, long var2, int var4) {
    48.     int var5;
    49.     do {
    50.         var5 = this.getIntVolatile(var1, var2);
    51.     } while(!this.compareAndSwapInt(var1, var2, var5, var4));
    52.  
    53.     return var5;
    54. }
    55.  
    56. public final long getAndSetLong(Object var1, long var2, long var4) {
    57.     long var6;
    58.     do {
    59.         var6 = this.getLongVolatile(var1, var2);
    60.     } while(!this.compareAndSwapLong(var1, var2, var6, var4));
    61.  
    62.     return var6;
    63. }
    64.  
    65. public final Object getAndSetObject(Object var1, long var2, Object var4) {
    66.     Object var5;
    67.     do {
    68.         var5 = this.getObjectVolatile(var1, var2);
    69.     } while(!this.compareAndSwapObject(var1, var2, var5, var4));

    Unsafe CAS 操作

    下面我们讲解Unsafe来进行CAS操作的具体代码：

    1. /*unsafe实现字段更新*/
    2.  
    3. // 主函数
    4. public class unsafeOperator{
    5.     
    6.     Unsafe unsafe = UnsafeAccessor.getUnsafe();
    7.     Field id = Student.class.getDeclaredField("id");
    8.     Field name = Student.class.getDeclaredField("name");
    9.     
    10.     // 获得成员变量的偏移量
    11.     long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id);
    12.     long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);
    13.     Student student = new Student();
    14.     
    15.     // 使用 cas 方法替换成员变量的值
    16.     UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20); // 返回 true
    17.     UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, "张三"); // 返回 true
    18.     System.out.println(student);
    19. }
    20.  
    21. // 学生类
    22. @Data
    23. class Student {
    24.     volatile int id;
    25.     volatile String name;
    26. }
    27.  
    28. // 输出
    29. Student(id=20, name=张三) 
    30.  
    31. /*unsafe实现原子整数*/
    32.  
    33. // 主函数
    34. class AtomicData {
    35.     private volatile int data;
    36.     static final Unsafe unsafe;
    37.     static final long DATA_OFFSET;
    38.     static {
    39.         unsafe = UnsafeAccessor.getUnsafe();
    40.         try {
    41.             // data 属性在 DataContainer 对象中的偏移量，用于 Unsafe 直接访问该属性
    42.             DATA_OFFSET = unsafe.objectFieldOffset(AtomicData.class.getDeclaredField("data"));
    43.         } catch (NoSuchFieldException e) {
    44.             throw new Error(e);
    45.         }
    46.     }
    47.     public AtomicData(int data) {
    48.         this.data = data;
    49.     }
    50.     public void decrease(int amount) {
    51.         int oldValue;
    52.         while(true) {
    53.             // 获取共享变量旧值，可以在这一行加入断点，修改 data 调试来加深理解
    54.             oldValue = data;
    55.             // cas 尝试修改 data 为 旧值 + amount，如果期间旧值被别的线程改了，返回 false
    56.             if (unsafe.compareAndSwapInt(this, DATA_OFFSET, oldValue, oldValue - amount)) {
    57.                 return;
    58.             }
    59.         }
    60.     }
    61.     public int getData() {
    62.         return data;
    63.     }
    64. }
    65.  
    66. // Account
    67. Account.demo(new Account() {
    68.     AtomicData atomicData = new AtomicData(10000);
    69.     @Override
    70.     public Integer getBalance() {
    71.         return atomicData.getData();
    72.     }
    73.     @Override
    74.     public void withdraw(Integer amount) {
    75.         atomicData.decrease(amount);
    76.     }
    77. });
    78.  
    79. /*手动实现原子整数完整版+测试*/
    80.  
    81. public class UnsafeAtomicTest{
    82.     public static void main(String[] args) {
    83.         //赋初始值10000，调用demo后正确的输出结果为0
    84.         AccountImpl account = new AccountImpl(10000);
    85.         //结果正确地输出0
    86.         account.demo();
    87.     }
    88. }
    89.  
    90. interface Account{
    91.     //获取balance的方法
    92.     int getBalance();
    93.     //取款的方法
    94.     void decrease(int amount);
    95.     //演示多线程取款，检查安全性。
    96.     default void demo(){
    97.         ArrayList<Thread> ts = new ArrayList<>(1000);
    98.         for (int i = 0; i < 1000; i++) {
    99.             ts.add(new Thread(() -> {
    100.                 decrease(10);
    101.             }));
    102.         }
    103.         for (Thread t:ts) {
    104.             t.start();
    105.         }
    106.         for (Thread t:ts) {
    107.             try {
    108.                 t.join();
    109.             } catch (InterruptedException e) {
    110.                 e.printStackTrace();
    111.             }
    112.         }
    113.         System.out.println(getBalance());
    114.     }
    115. }
    116. //实现账户类，使用手动实现的原子整数作为余额类型
    117. class AccountImpl implements Account{
    118.  
    119.     UnsafeAtomicInteger balance;
    120.  
    121.     public AccountImpl(int balance){
    122.         this.balance = new UnsafeAtomicInteger(balance);
    123.     }
    124.  
    125.     @Override
    126.     public int getBalance() {
    127.         return balance.get();
    128.     }
    129.  
    130.     @Override
    131.     public void decrease(int amount) {
    132.         balance.getAndAccumulate(amount,(x,y) -> y - x);
    133.     }
    134.  
    135. }
    136. //手动实现原子整数类
    137. class UnsafeAtomicInteger {
    138.     //将value声明为volatile，因为乐观锁需要可见性。
    139.     private volatile int value;
    140.     //需要Unsafe的cas本地方法实现操作。
    141.     private static final Unsafe unsafe;
    142.     //偏移量，这两个变量很重要且通用、不可变，所以均声明为private static final
    143.     private static final long offset;
    144.  
    145.     static{
    146.         //静态代码块初始化unsafe
    147.         unsafe = UnsafeAccessor.getUnsafe();
    148.  
    149.         try {
    150.             //获取value在当前类中的偏移量
    151.             offset = unsafe.objectFieldOffset(UnsafeAtomicInteger.class.getDeclaredField("value"));
    152.         } catch (NoSuchFieldException e) {
    153.             e.printStackTrace();
    154.             //待研究
    155.             throw new Error(e);
    156.         }
    157.     }
    158.  
    159.     public UnsafeAtomicInteger(){
    160.  
    161.     }
    162.  
    163.     public UnsafeAtomicInteger(int value){
    164.         this.value = value;
    165.     }
    166.  
    167.     public final int get(){
    168.         return value;
    169.     }
    170.  
    171.     public final boolean compareAndSet(int expext,int update){
    172.         return unsafe.compareAndSwapInt(this, offset, expext, update);
    173.     }
    174.  
    175.     public final int getAndIncrement(){
    176.         //局部变量是必须的，因为多次从主存中读取value的值不可靠。
    177.         int oldValue;
    178.         while (true){
    179.             oldValue = value;
    180.             if(unsafe.compareAndSwapInt(this,offset,oldValue,oldValue + 1)){
    181.                 return oldValue;
    182.             }
    183.         }
    184.     }
    185.  
    186.     public final int incrementAndGet(){
    187.         int oldValue;
    188.         while (true){
    189.             oldValue = value;
    190.             if (unsafe.compareAndSwapInt(this, offset, oldValue, oldValue + 1)) {
    191.                 return oldValue + 1;
    192.             }
    193.         }
    194.     }
    195.  
    196.     public final int getAndDecrement(){
    197.         int oldValue;
    198.         while (true){
    199.             oldValue = value;
    200.             if (unsafe.compareAndSwapInt(this, offset, oldValue, oldValue - 1)) {
    201.                 return oldValue;
    202.             }
    203.         }
    204.     }
    205.  
    206.     public final int decrementAndGet(){
    207.         int oldValue;
    208.         while (true){
    209.             oldValue = value;
    210.             if (unsafe.compareAndSwapInt(this, offset, oldValue, oldValue - 1)) {
    211.                 return oldValue - 1;
    212.             }
    213.         }
    214.     }
    215.  
    216.     public final int getAndUpdate(IntUnaryOperator operator){
    217.         int oldValue;
    218.         int newValue;
    219.         while (true){
    220.             oldValue = value;
    221.             newValue = operator.applyAsInt(oldValue);
    222.             if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
    223.                 return oldValue;
    224.             }
    225.         }
    226.     }
    227.  
    228.     public final int updateAndGet(IntUnaryOperator operator){
    229.         int oldValue;
    230.         int newValue;
    231.         while (true){
    232.             oldValue = value;
    233.             newValue = operator.applyAsInt(oldValue);
    234.             if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
    235.                 return newValue;
    236.             }
    237.         }
    238.     }
    239.  
    240.     public final int getAndAccumulate(int x, IntBinaryOperator operator){
    241.         int oldValue;
    242.         int newValue;
    243.         while (true){
    244.             oldValue = value;
    245.             newValue = operator.applyAsInt(x,oldValue);
    246.             if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
    247.                 return newValue;
    248.             }
    249.         }
    250.     }
    251.  
    252.     public final int accumulateAndGet(int x, IntBinaryOperator operator){
    253.         int oldValue;
    254.         int newValue;
    255.         while (true){
    256.             oldValue = value;
    257.             newValue = operator.applyAsInt(x,oldValue);
    258.             if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
    259.                 return oldValue;
    260.             }
    261.         }
    262.     }
    263. }
    264.  
    265. class UnsafeAccessor{
    266.     public static Unsafe getUnsafe(){
    267.         Field field;
    268.         Unsafe unsafe = null;
    269.         try {
    270.             field  = Unsafe.class.getDeclaredField("theUnsafe");
    271.             field.setAccessible(true);
    272.             unsafe = (Unsafe)field.get(null);
    273.         } catch (Exception e) {
    274.             e.printStackTrace();
    275.         }
    276.         return unsafe;
    277.     }
    278. }

    总结

    我们在这里做一下该篇文章核心内容总结：

    • CAS 与 volatile
    • API
      • 原子整数
      • 原子引用
      • 原子数组
      • 字段更新器
      • 原子累加器
    • Unsafe
    • 伪共享
  • 相关阅读:
    Vue中父子组件通信方式
    SA实战 ·《SpringCloud Alibaba实战》第03章-微服务介绍
    C#中的事件聚合器实现方法
    鼠标拖拽拖动盒子时，与盒子内某些点击事件冲突问题解决
    如何全面提升架构设计的质量
    56资源网系统源码搭建知识付费-含源码
    SDRAM与DRAM
    java毕业设计旅游攻略开发系统mybatis+源码+调试部署+系统+数据库+lw
    Go 使用 RabbitMQ---------------之一
    WPF 分组
  • 原文地址：https://blog.csdn.net/sinat_40572875/article/details/127932635