devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

共享模型之无锁

作者：笔触狂放9 | 2024-07-21 11:08:16

赞

踩

共享模型之无锁

一、问题提出

1.1 需求描述

        有如下的需求，需要保证 account.withdraw() 取款方法的线程安全，代码如下：

  1. interface Account {
  2.     // 获取余额
  3.     Integer getBalance();
  4.  
  5.     // 取款
  6.     void withdraw(Integer amount);
  7.  
  8.     /**
  9.      * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
  10.      * 如果初始余额为 10000 那么正确的结果应当是 0
  11.      */
  12.     static void demo(Account account) {
  13.         List<Thread> ts = new ArrayList<>();
  14.         long start = System.nanoTime();
  15.         for (int i = 0; i < 1000; i++) {
  16.             ts.add(new Thread(() -> {
  17.                 account.withdraw(10);
  18.             }));
  19.         }
  20.         ts.forEach(Thread::start);
  21.         ts.forEach(t -> {
  22.             try {
  23.                 t.join();
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         });
  28.         long end = System.nanoTime();
  29.         System.out.println(account.getBalance()
  30.                 + " cost: " + (end - start) / 1000_000 + " ms");
  31.     }
  32. }
  1. class AccountUnsafe implements Account {
  2.     private Integer balance;
  3.  
  4.     public AccountUnsafe(Integer balance) {
  5.         this.balance = balance;
  6.     }
  7.  
  8.     @Override
  9.     public Integer getBalance() {
  10.         return balance;
  11.     }
  12.  
  13.     @Override
  14.     public void withdraw(Integer amount) {
  15.         balance -= amount;
  16.     }
  17.  
  18.     public static void main(String[] args) {
  19.         Account.demo(new AccountUnsafe(10000));
  20.     }
  21. }

        原有的实现并不是线程安全的，执行结果如下所示： 

1.2 问题分析

        为什么会出现线程安全问题？是因为在多线程的环境下取款的 withdraw() 方法里面是临界区，存在指令交错的行为。

1.3 加锁解决

        首先想到的解决方式就是给 Account 对象加锁，如下代码：

  1. class AccountUnsafe implements Account {
  2.     private Integer balance;
  3.     public AccountUnsafe(Integer balance) {
  4.  
  5.         this.balance = balance;
  6.     }
  7.     @Override
  8.     public Integer getBalance() {
  9.         synchronized (this){
  10.             return balance;
  11.         }
  12.     }
  13.     @Override
  14.     public void withdraw(Integer amount) {
  15.         synchronized (this){
  16.             balance -= amount;
  17.         }
  18.  
  19.     }
  20.     public static void main(String[] args) {
  21.         Account.demo(new AccountUnsafe(10000));
  22.     }
  23. }

         运行结果如下，没有任何问题。

1.4 无锁解决

        也可以通过无锁的方式解决上述的问题，如下代码：

  1. public class AccountSafe implements Account{
  2.  
  3.     private AtomicInteger balance;
  4.     public AccountSafe(Integer balance) {
  5.  
  6.         this.balance = new AtomicInteger(balance);
  7.     }
  8.     @Override
  9.     public Integer getBalance() {
  10.         return balance.get();
  11.     }
  12.  
  13.     @Override
  14.     public void withdraw(Integer amount) {
  15.         while(true){
  16.             int prev = balance.get();
  17.             int next = prev - amount;
  18.             if(balance.compareAndSet(prev,next)){
  19.                 break;
  20.             }
  21.         }
  22.     }
  23.  
  24.     public static void main(String[] args) {
  25.         Account.demo(new AccountSafe(10000));
  26.     }
  27. }

         运行结果如下，没有任何问题。

二、CAS 与 volatile

2.1 CAS

        在上一小结看到的使用 AtomicInteger 的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？

  1.     @Override
  2.     public void withdraw(Integer amount) {
  3.         // 需要不断尝试，直到成功为止
  4.         while(true){
  5.             // 比如拿到了旧值 1000
  6.             int prev = balance.get();
  7.             // 在这个基础上 1000-10 = 990
  8.             int next = prev - amount;
  9.             /*
  10.             * compareAndSet 会做一个检查，在 set 值之前先比较 prev 和当前值
  11.             *   若 prev 值和当前值一致，则用 next 设置为新值，并返回 true 表示成功。
  12.             *   若 prev 值和当前值不一致，则 next 作废，返回 false 表示失败，进入 while 下次循环重试
  13.             * */
  14.             if(balance.compareAndSet(prev,next)){
  15.                 break;
  16.             }
  17.         }
  18.     }

        这里面最关键的就是 compareAndSet() 方法，它的简称就是 CAS（也有 compare and swap 的说法），此方法是一个原子操作。

        其实 CAS 的底层是 lock cmpxchg 指令，在单核 CPU 和多核 CPU 下都能够保证原子性。

2.2 volatile

        获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。

        它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见。

        volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题（不能保证原子性）

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

2.3 为什么无锁效率高

        无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。

        但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。

2.4 CAS 的特点

        将 CAS 和 volatile 结合使用可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。

        CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试。

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

        CAS 体现的是无锁并发、无阻塞并发。因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一；但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响 。

三、原子整数

        在 JUC 并发包下提供了一些原子整数的工具类，如：AtomicBoolean、AtomicInteger 和 AtomicLong，这几个类的用法类似，下面就以 AtomicInteger 为例，介绍下常用的方法。

  1. public class AtomicTest {
  2.  
  3.     public static void main(String[] args) {
  4.         // 无参构造的初始值为 0，有参构造的初始值需要自己指定
  5.         AtomicInteger i = new AtomicInteger(0);
  6.  
  7.         // 获取并自增，返回 0，类似于 i++
  8.         System.out.println(i.getAndIncrement());
  9.  
  10.         // 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
  11.         System.out.println(i.incrementAndGet());
  12.  
  13.         // 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
  14.         System.out.println(i.decrementAndGet());
  15.  
  16.         // 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
  17.         System.out.println(i.getAndDecrement());
  18.  
  19.         // 获取并加值（i = 0, 结果 i = 5, 返回 0）
  20.         System.out.println(i.getAndAdd(5));
  21.  
  22.         // 加值并获取（i = 5, 结果 i = 0, 返回 0）
  23.         System.out.println(i.addAndGet(-5));
  24.  
  25.         // 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
  26.         // 其中函数中的操作能保证原子，但函数需要无副作用
  27.         System.out.println(i.getAndUpdate(p -> p - 2));
  28.         
  29.         // 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
  30.         // 其中函数中的操作能保证原子，但函数需要无副作用
  31.         System.out.println(i.updateAndGet(p -> p + 2));
  32.         
  33.         // 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
  34.         // 其中函数中的操作能保证原子，但函数需要无副作用
  35.         // getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
  36.         // getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
  37.         System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
  38.         
  39.         // 计算并获取（i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0）
  40.         // 其中函数中的操作能保证原子，但函数需要无副作用
  41.         System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
  42.     }
  43. }

四、原子引用

        为什么需要原子引用，因为共享的数据并不一定都是基本数据类型的，还有可能是小数类型，那么我们就可以使用原子引用来保证其中的共享变量操作时的线程安全。

        原子引用分为如下几种：AtomicReference、AtomicMarkableReference、AtomicStampedReference

4.1 AtomicReference

        以最开始的例子为例，假设此时的账户余额是 BigDecimal 类型，我们就需要使用 AtomicReferenceAtomicReference，如下代码：

  1. interface Account {
  2.     // 获取余额
  3.     BigDecimal getBalance();
  4.  
  5.     // 取款
  6.     void withdraw(BigDecimal amount);
  7.  
  8.     /**
  9.      * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
  10.      * 如果初始余额为 10000 那么正确的结果应当是 0
  11.      */
  12.     static void demo(Account account) {
  13.         List<Thread> ts = new ArrayList<>();
  14.         long start = System.nanoTime();
  15.         for (int i = 0; i < 1000; i++) {
  16.             ts.add(new Thread(() -> {
  17.                 account.withdraw(BigDecimal.TEN);
  18.             }));
  19.         }
  20.         ts.forEach(Thread::start);
  21.         ts.forEach(t -> {
  22.             try {
  23.                 t.join();
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         });
  28.         long end = System.nanoTime();
  29.         System.out.println(account.getBalance()
  30.                 + " cost: " + (end - start) / 1000_000 + " ms");
  31.     }
  32. }
  1. public class AccountSafe implements Account{
  2.  
  3.     private AtomicReference<BigDecimal> balance;
  4.     public AccountSafe(BigDecimal balance) {
  5.  
  6.         this.balance = new AtomicReference(balance);
  7.     }
  8.     @Override
  9.     public BigDecimal getBalance() {
  10.  
  11.         return balance.get();
  12.     }
  13.     @Override
  14.     public void withdraw(BigDecimal amount) {
  15.         // 需要不断尝试，直到成功为止
  16.         while(true){
  17.             BigDecimal prev = balance.get();
  18.             // 调用 subtract 相当于减的操作
  19.             BigDecimal next = prev.subtract(amount);
  20.             if(balance.compareAndSet(prev,next)){
  21.                 break;
  22.             }
  23.         }
  24.     }
  25.     public static void main(String[] args) {
  26.         Account.demo(new AccountSafe(new BigDecimal("10000")));
  27.     }
  28. }

        测试结果如下，没有任何问题。

4.2 ABA 问题

        主线程仅能判断出共享变量的值与最初值 A 是否相同，不能感知到这种从 A 改为 B 又 改回 A 的情况，这就是我们所说的 ABA 问题，如下代码：

  1. @Slf4j(topic = "c.test")
  2. public class Main8 {
  3.     static AtomicReference<String> ref = new AtomicReference<>("A");
  4.  
  5.     public static void main(String[] args) throws InterruptedException {
  6.         log.debug("main start...");
  7.         // 获取值 A
  8.         // 这个共享变量被它线程修改过？
  9.         String prev = ref.get();
  10.         other();
  11.         Thread.sleep(1000);
  12.         // 尝试改为 C
  13.         log.debug("change A->C {}", ref.compareAndSet(prev, "C"));
  14.     }
  15.  
  16.     private static void other() throws InterruptedException {
  17.         new Thread(() -> {
  18.             log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));
  19.         }, "t1").start();
  20.         Thread.sleep(500);
  21.         new Thread(() -> {
  22.             log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));
  23.         }, "t2").start();
  24.     }
  25. }

        输出结果如下：

4.3 AtomicStampedReference

        如果主线程希望只要有其它线程动过了共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个版本号 AtomicStampedReference。

        AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如： A -> B -> A ->C ，通过 AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。如下代码：

  1. @Slf4j(topic = "c.test")
  2. public class Main9 {
  3.     // 不光给变量一个初始值，还给一个初始的版本号
  4.     static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
  5.  
  6.     public static void main(String[] args) throws InterruptedException {
  7.         log.debug("main start...");
  8.         // 获取值 A
  9.         String prev = ref.getReference();
  10.         // 获取版本号
  11.         int stamp = ref.getStamp();
  12.         log.debug("版本 {}", stamp);
  13.         // 如果中间有其它线程干扰，发生了 ABA 现象
  14.         other();
  15.         Thread.sleep(1000);
  16.         // 尝试改为 C，此时 compareAndSet 方法需要四个参数，当前值，期望值，当前版本号，期望版本号
  17.         log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
  18.     }
  19.  
  20.     private static void other() throws InterruptedException {
  21.         new Thread(() -> {
  22.             log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B",
  23.                     ref.getStamp(), ref.getStamp() + 1));
  24.             log.debug("更新版本为 {}", ref.getStamp());
  25.         }, "t1").start();
  26.         Thread.sleep(500);
  27.         new Thread(() -> {
  28.             log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A",
  29.                     ref.getStamp(), ref.getStamp() + 1));
  30.             log.debug("更新版本为 {}", ref.getStamp());
  31.         }, "t2").start();
  32.     }
  33. }

        可以看到，解决了 ABA 问题，更新并没有成功。 

4.4 AtomicMarkableReference

        但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，用一个布尔值就可以搞定，所以就有了 AtomicMarkableReference。

        如下案例，主人要检查垃圾袋满没满，是否需要倒垃圾，如果满了则更换新的垃圾袋；如果还空着呢，就用原有的垃圾袋。此时还有另外一个线程保洁阿姨，她负责倒空垃圾袋里面的垃圾，但是她还是用原来的垃圾袋，如果此时主人检查垃圾袋是空的就不用再去更换垃圾袋了。

        代码如下所示：

  1. @Slf4j(topic = "c.test")
  2. public class Main9 {
  3.     public static void main(String[] args) throws InterruptedException {
  4.         GarbageBag bag = new GarbageBag("装满了垃圾");
  5.         // 参数2 mark 可以看作一个标记，表示垃圾袋满了
  6.         AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
  7.         log.debug("主线程 start...");
  8.         GarbageBag prev = ref.getReference();
  9.         log.debug(prev.toString());
  10.         new Thread(() -> {
  11.             log.debug("打扫卫生的线程 start...");
  12.             bag.setDesc("空垃圾袋");
  13.             while (!ref.compareAndSet(bag, bag, true, false)) {
  14.             }
  15.             log.debug(bag.toString());
  16.         }).start();
  17.         Thread.sleep(1000);
  18.         log.debug("主线程想换一只新垃圾袋？");
  19.         boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
  20.         log.debug("换了么？" + success);
  21.         log.debug(ref.getReference().toString());
  22.     }
  23. }
  24.  
  25. class GarbageBag {
  26.     String desc;
  27.  
  28.     public GarbageBag(String desc) {
  29.         this.desc = desc;
  30.     }
  31.  
  32.     public void setDesc(String desc) {
  33.         this.desc = desc;
  34.     }
  35.  
  36.     @Override
  37.     public String toString() {
  38.         return super.toString() + " " + desc;
  39.     }
  40. }

         输出结果如下所示：

五、原子数组

        原子数据保护的是数组里面的元素，常用的原子数组类是 AtomicIntegerArray、AtomicLongArray 和 AtomicReferenceArray，测试类的代码如下所示：

  1. @Slf4j(topic = "c.test")
  2. public class Main9 {
  3.     public static void main(String[] args) throws InterruptedException {
  4.         // 不安全的数组
  5.         demo(
  6.                 () -> new int[10],
  7.                 (array) -> array.length,
  8.                 (array, index) -> array[index]++,
  9.                 array -> System.out.println(Arrays.toString(array))
  10.         );
  11.         // 安全的数组
  12.         demo(
  13.                 () -> new AtomicIntegerArray(10),
  14.                 (array) -> array.length(),
  15.                 (array, index) -> array.getAndIncrement(index),
  16.                 array -> System.out.println(array)
  17.         );
  18.     }
  19.  
  20.     /**
  21.      * 参数1，提供数组、可以是线程不安全数组或线程安全数组
  22.      * 参数2，获取数组长度的方法
  23.      * 参数3，自增方法，回传 array, index
  24.      * 参数4，打印数组的方法
  25.      */
  26.     // supplier 提供者 无中生有 ()->结果
  27.     // function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
  28.     // consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->
  29.     private static <T> void demo(
  30.             Supplier<T> arraySupplier,
  31.             Function<T, Integer> lengthFun,
  32.             BiConsumer<T, Integer> putConsumer,
  33.             Consumer<T> printConsumer) {
  34.         List<Thread> ts = new ArrayList<>();
  35.         T array = arraySupplier.get();
  36.         int length = lengthFun.apply(array);
  37.         for (int i = 0; i < length; i++) {
  38.             // 每个线程对数组作 10000 次操作
  39.             ts.add(new Thread(() -> {
  40.                 for (int j = 0; j < 10000; j++) {
  41.                     putConsumer.accept(array, j % length);
  42.                 }
  43.             }));
  44.         }
  45.         ts.forEach(t -> t.start()); // 启动所有线程
  46.         ts.forEach(t -> {
  47.             try {
  48.                 t.join();
  49.             } catch (InterruptedException e) {
  50.                 e.printStackTrace();
  51.             }
  52.         }); // 等所有线程结束
  53.         printConsumer.accept(array);
  54.     }
  55. }

        输出结果如下所示：

六、字段更新器

        字段更新器保护的是对象里面的某个属性，即对这个属性进行原子操作，但是需要配合 volatile 修饰的字段使用，否则会出现异常，如下代码：

  1. public class Test5 {
  2.     private volatile int field;
  3.  
  4.     public static void main(String[] args) {
  5.         AtomicIntegerFieldUpdater fieldUpdater =
  6.                 AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");
  7.         Test5 test5 = new Test5();
  8.         fieldUpdater.compareAndSet(test5, 0, 10);
  9.         // 修改成功 field = 10
  10.         System.out.println(test5.field);
  11.         // 修改成功 field = 20
  12.         fieldUpdater.compareAndSet(test5, 10, 20);
  13.         System.out.println(test5.field);
  14.         // 修改失败 field = 20
  15.         fieldUpdater.compareAndSet(test5, 10, 30);
  16.         System.out.println(test5.field);
  17.     }
  18. }

         输出结果如下：

七、原子累加器

        累加器顾名思义，就是对一个整数进行累加的操作，在 jdk8 以后，新增了几个专门用于累加操作的工具类，比如：LongAdder、LongAccumulator 等，他们的性能要比我们的 AtomicLong 性能要高很多。

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

  1. public class Test5 {
  2.  
  3.     public static void main(String[] args) {
  4.         for (int i = 0; i < 5; i++) {
  5.             demo(() -> new LongAdder(), adder -> adder.increment());
  6.         }
  7.         for (int i = 0; i < 5; i++) {
  8.             demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
  9.         }
  10.     }
  11.  
  12.     private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
  13.         T adder = adderSupplier.get();
  14.         long start = System.nanoTime();
  15.         List<Thread> ts = new ArrayList<>();
  16.         // 4 个线程，每人累加 50 万
  17.         for (int i = 0; i < 40; i++) {
  18.             ts.add(new Thread(() -> {
  19.                 for (int j = 0; j < 500000; j++) {
  20.                     action.accept(adder);
  21.                 }
  22.             }));
  23.         }
  24.         ts.forEach(t -> t.start());
  25.         ts.forEach(t -> {
  26.             try {
  27.                 t.join();
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         });
  32.         long end = System.nanoTime();
  33.         System.out.println(adder + " cost:" + (end - start) / 1000_000);
  34.     }
  35. }

        输出结果如下所示：可以看到，相差的时间还是蛮大的：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/860619
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号