《JUC并发编程 - 高级篇》05 -共享模型之无锁（CAS | 原子整数 | 原子引用 | 原子数组 | 字段更新器 | 原子累加器 | Unsafe类）

川长思鸟来 2023-10-05 23:08 46阅读 0赞

#### 文章目录 ####

*  五、共享模型之无锁
 *   *  5.1 问题提出
     *   *  5.1.1 为么不安全
         *  5.1.2 解决思路1 - 锁
         *  5.1.3 解决思路2 - 无锁
     *  5.2 CAS 与 volatile
     *   *  5.2.1 CAS和volatile的关系
         *  5.2.2 为什么无锁效率高
         *  5.2.3 CAS 的特点
     *  5.3 原子整数
     *  5.4 原子引用
     *   *  5.4.1 不安全实现
         *  5.4.2 安全实现-使用锁
         *  5.4.3 安全实现-使用CAS
         *  5.4.4 ABA 问题及解决
     *  5.5 原子数组
     *  5.6 字段更新器
     *  5.7 原子累加器
     *   *  5.7.1 累加器性能比较
         *  \* 源码之 LongAdder
         *  5.7.2 CAS锁
         *  \* 原理之伪共享
     *  5.8 Unsafe
     *   *  5.8.1 Unsafe CAS 操作
         *  6.8.2 unsafe对象模拟实现原子整数
     *  本章小结

## 五、共享模型之无锁 ##

### 5.1 问题提出 ###

有如下需求，保证 `account.withdraw` 取款方法的线程安全

interface Account {
        
        // 获取余额
        Integer getBalance();
    
        // 取款
        void withdraw(Integer amount);
    
        /**
         * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
         * 如果初始余额为 10000 那么正确的结果应当是 0
         */
        static void demo(Account account) {
        
            List<Thread> ts = new ArrayList<>();
            for (int i = 0; i < 1000; i++) {
        
                ts.add(new Thread(() -> {
        
                    account.withdraw(10);
                }));
            }
            long start = System.nanoTime();
            ts.forEach(Thread::start);
            ts.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            long end = System.nanoTime();
            System.out.println(account.getBalance()
                    + " cost: " + (end-start)/1000_000 + " ms");
        }
    }

原有实现并不是线程安全的

class AccountUnsafe implements Account {
        
    
        private Integer balance;
    
        public AccountUnsafe(Integer balance) {
        
            this.balance = balance;
        }
    
        @Override
        public Integer getBalance() {
        
            return this.balance;
        }
    
        @Override
        public void withdraw(Integer amount) {
        
        	this.balance -= amount;
        }
    }

测试代码

public static void main(String[] args) {
        
            Account account = new AccountUnsafe(10000);
            Account.demo(account);
    }

执行测试代码，某次执行结果

280 cost: 82 ms

#### 5.1.1 为么不安全 ####

`withdraw`方法是临界区，会存在线程安全问题

查看下字节码

ALOAD 0	 													   // <- this
    ALOAD 0
    GETFIELD cn/itcast/AccountUnsafe.balance : Ljava/lang/Integer; // <- this.balance
    INVOKEVIRTUAL java/lang/Integer.intValue ()I 				   // 拆箱
    ALOAD 1 													   // <- amount
    INVOKEVIRTUAL java/lang/Integer.intValue ()I 				   // 拆箱
    ISUB 														   // 减法
    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;  // 结果装箱
    PUTFIELD cn/itcast/AccountUnsafe.balance : Ljava/lang/Integer; // -> this.balance

多线程在执行过程中可能会出现指令的交错，从而结果错误！

#### 5.1.2 解决思路1 - 锁 ####

首先想到的是给 Account 对象加锁

class AccountUnsafe implements Account{
        
    
        private Integer balance;
    
        public AccountUnsafe(Integer balance) {
        
            this.balance = balance;
        }
    
        @Override
        public Integer getBalance() {
        
            return this.balance;
        }
    
        @Override
        public void withdraw(Integer amount) {
        
            synchronized (this){
        
                this.balance -= amount;
            }
        }
    }

运行结果

0 cost: 122 ms

#### 5.1.3 解决思路2 - 无锁 ####

class AccountCas implements Account{
        
        private AtomicInteger balance;
    
        public AccountCas(int balance) {
        
            this.balance = new AtomicInteger(balance);
        }
    
        @Override
        public Integer getBalance() {
        
            return balance.get();
        }
    
        @Override
        public void withdraw(Integer amount) {
        
            while (true){
        
                //获取金额的最新值
                int prev = balance.get();
                //要修改的金额
                int next = prev - amount;
                //真正修改
                if(balance.compareAndSet(prev,next)){
        
                    break;
                }
            }
        }
    }

运行结果

0 cost: 63 ms

### 5.2 CAS 与 volatile ###

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

public void withdraw(Integer amount) {
        
        while(true) {
        
            // 需要不断尝试，直到成功为止
            while (true) {
        
                // 比如拿到了旧值 1000
                int prev = balance.get();
                // 在这个基础上 1000-10 = 990
                int next = prev - amount;
                /*
                    compareAndSet 正是做这个检查，在 set 前，先比较 prev 与当前值
                    - 不一致了，next 作废，返回 false 表示失败
                    比如，别的线程已经做了减法，当前值已经被减成了 990
                    那么本线程的这次 990 就作废了，进入 while 下次循环重试
                    - 一致，以 next 设置为新值，返回 true 表示成功
                    */
                if (balance.compareAndSet(prev, next)) {
        
                    break;
                }
            }
        }
    }

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

//判断期望值和当前主存中的值是否一致，如果一致则将其更新成update，否则继续重试
    public final boolean compareAndSet(int expect,int update)

![image-20220716155350971][]

**分析：**

*  线程1拿到 balance后，进行-10运算 。在这个过程中，balance已经被线程2修改成90了。当线程1进行cas操作时，发现oldBalance和newBalance不一致，就放弃进行设置next，尝试进行下一轮
 *  当进行到第三轮，cas比较时，发现oldBalance和newBalance一致，说明并没有被其他线程修改，就将balance更新成 next

**注意**

*  其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。
 *  在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的。

#### 5.2.1 CAS和volatile的关系 ####

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

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

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

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

#### 5.2.2 为什么无锁效率高 ####

*  无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 `synchronized`会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。
 *  打个比喻：线程就好像高速跑道上的赛车，高速运行时，速度超快，一旦发生上下文切换，就好比赛车要减速、熄火，等被唤醒又得重新打火、启动、加速… 恢复到高速运行，代价比较大
 *  但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。

![image-20220716171451791][]

所以CAS在多核CPU下才能发挥作用，而且线程数最好不要超过CPU数，否则也会发生上下文切换，影响效率。

#### 5.2.3 CAS 的特点 ####

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

*  CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。（基于乐观锁，但本质上没有上锁）
 *  synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。
 *  CAS 体现的是无锁并发（不加锁）、无阻塞并发(上下文切换少)，请仔细体会这两句话的意思
    
     *  因为没有使用 `synchronized`，所以线程不会陷入阻塞，这是效率提升的因素之一
     *  但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

### 5.3 原子整数 ###

J.U.C 并发包提供了：

*  AtomicBoolean
 *  AtomicInteger
 *  AtomicLong

以 AtomicInteger 为例

public class Test43 {
        
        public static void main(String[] args) {
        
            AtomicInteger i = new AtomicInteger(0);
    
            System.out.println(i.getAndIncrement());// i++   结果 i  = 1,返回 0
            System.out.println(i.incrementAndGet());// ++i   结果 i  = 2,返回 2
            System.out.println(i.getAndDecrement());// i--   结果 i  = 1,返回 2
            System.out.println(i.decrementAndGet());// --i   结果 i  = 0,返回 0
    
            System.out.println(i.getAndAdd(5));// 获取并加值 结果 i = 5, 返回 0
            System.out.println(i.addAndGet(5));// 加值并获取 结果 i = 10,返回 10
    
            System.out.println(i.updateAndGet(value -> value * 10));// 更新(+-*/)并获取 结果 i=100,返回100
            System.out.println(i.getAndUpdate(value -> value / 2));//  获取并更新       结果 i=50,返回1002
            System.out.println(i.get());//50
        }
    }

updateAndGet()的原理

*  使用CAS实现updateAndGet（）方法

![28851772d182388bf995526a17bfdd5d.png][]

*  查看一下JDK的updateAndGet的方法源码，和咱们实现的几乎一样！Nice！

![image-20220716231350601][]

### 5.4 原子引用 ###

为什么需要原子引用类型？— 用于保证引用类型数据的原子性

*  AtomicReference
 *  AtomicMarkableReference
 *  AtomicStampedReference

有如下方法

interface DecimalAccount {
        
        // 获取余额
        BigDecimal getBalance();
    
        // 取款
        void withdraw(BigDecimal amount);
    
        /**
         * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
         * 如果初始余额为 10000 那么正确的结果应当是 0
         */
        static void demo(DecimalAccount account) {
        
            List <Thread> ts = new ArrayList <>();
            for (int i = 0; i < 1000; i++) {
        
                ts.add(new Thread(() -> {
        
                    account.withdraw(BigDecimal.TEN);
                }));
            }
            ts.forEach(Thread::start);
            ts.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            System.out.println(account.getBalance());
        }
    }

**试着提供不同的 DecimalAccount 实现，实现安全的取款操作**

#### 5.4.1 不安全实现 ####

public class Test27 {
        
        public static void main(String[] args) {
        
            DecimalAccount.demo(new DecimalAccountUnsafe(new BigDecimal("10000")));
        }
    }
    
    class DecimalAccountUnsafe implements DecimalAccount {
        
        BigDecimal balance;
        public DecimalAccountUnsafe(BigDecimal balance) {
        
            this.balance = balance;
        }
        @Override
        public BigDecimal getBalance() {
        
            return balance;
        }
        @Override
        public void withdraw(BigDecimal amount) {
        
            BigDecimal balance = this.getBalance();
            this.balance = balance.subtract(amount);
        }
    }

#### 5.4.2 安全实现-使用锁 ####

class DecimalAccountUnsafe implements DecimalAccount {
        
        BigDecimal balance;
        public DecimalAccountUnsafe(BigDecimal balance) {
        
            this.balance = balance;
        }
        @Override
        public BigDecimal getBalance() {
        
            return balance;
        }
        @Override
        public void withdraw(BigDecimal amount) {
        
            synchronized (this){
        
                BigDecimal balance = this.getBalance();
                this.balance = balance.subtract(amount);
            }
    
        }
    }

#### 5.4.3 安全实现-使用CAS ####

public class Test27 {
        
        public static void main(String[] args) {
        
            DecimalAccount.demo(new DecimalAccountCas(new BigDecimal("10000")));
        }
    }
    
    class DecimalAccountCas implements DecimalAccount{
        
    
        private AtomicReference<BigDecimal> balance;
    
        public DecimalAccountCas(BigDecimal balance) {
        
            this.balance = new AtomicReference <>(balance);
        }
    
        @Override
        public BigDecimal getBalance() {
        
            return balance.get();
        }
    
        @Override
        public void withdraw(BigDecimal amount) {
        
            while (true){
        
                BigDecimal prev = balance.get();
                BigDecimal next = prev.subtract(amount);
                if(balance.compareAndSet(prev,next)){
        
                    break;
                }
            }
        }
    }

#### 5.4.4 ABA 问题及解决 ####

**1. ABA 问题**

\*\*问题描述：\*\*一个线程t1在修改共享变量w前，另外一个线程t2也对w进行了修改，但是w修改前后值相等。最终会导致t1也会修改成功！ 我们期望的是，只有其他线程修改w了，t1本轮就修改失败！

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 15:15
     */
    @Slf4j(topic = "c.Test28")
    public class Test28 {
        
    
        static AtomicReference<String> ref = new AtomicReference <>("A");
    
        public static void main(String[] args) {
        
            log.debug("main start...");
            //获取值
            //这个共享变量被其他线程修改过且修改前后值未变能否可以检测出来呢? ---目前的写发不可以
            String prev = ref.get();
            //如果中间有其他线程干扰，发生了ABA现象，则依旧可以修改成功
            other();
            Sleeper.sleep(1);
            //尝试改为C
            log.debug("change A->C {}",ref.compareAndSet(prev,"C"));
        }
    
        private static void other(){
        
            new Thread(()->{
        
                log.debug("change A->B {}",ref.compareAndSet(ref.get(),"B"));
            },"t1").start();
            Sleeper.sleep(0.5);
            new Thread(()->{
        
                log.debug("change B->A {}",ref.compareAndSet(ref.get(),"A"));
            },"t2").start();
        }
    
    }

输出为：

16:03:10.444 c.Test28 [main] - main start...
    16:03:10.481 c.Test28 [t1] - change A->B true
    16:03:10.995 c.Test28 [t2] - change B->A true
    16:03:12.009 c.Test28 [main] - change A->C true

\*\*结论：\*\*主线程仅能判断出共享变量的值与最初值 A 是否相同，不能感知到这种从 A 改为 B 又 改回 A 的情况，如果主线程希望：

只要有其它线程【动过了】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个**版本号** — 可以通过我们接下来的`AtomicStampedReference` 实现

**2. AtomicStampedReference**

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 15:15
     */
    @Slf4j(topic = "c.Test29")
    public class Test29 {
        
    
        static AtomicStampedReference <String> ref = new AtomicStampedReference <>("A",0);
    
        public static void main(String[] args) {
        
            log.debug("main start...");
            //获取值
            //这个共享变量被其他线程修改过且修改前后值未变能否可以检测出来呢? ---目前的写发可以
            String prev = ref.getReference();
            //获取版本号
            int stamp = ref.getStamp();
            log.debug("版本 {}",stamp);
            //如果中间有其他线程干扰，发生了ABA现象，由于含有stamp，则无法修改成功
            other();
            Sleeper.sleep(1);
            //尝试改为C
            log.debug("change A->C {}",ref.compareAndSet(prev,"C",stamp,stamp+1));
        }
    	//注意：必须先获取版本号，再获取值，才能解决ABA。
    	//如果先获取值在获取版本号之前就ABA了再获取版本号，就是ABA之后的。
        private static void other(){
        
            new Thread(()->{
        
                log.debug("change A->B {}",ref.compareAndSet(ref.getReference(),"B",ref.getStamp(),ref.getStamp()+1));
                log.debug("版本 {}",ref.getStamp());
            },"t1").start();
            Sleeper.sleep(0.5);
            new Thread(()->{
        
                log.debug("change B->A {}",ref.compareAndSet(ref.getReference(),"A",ref.getStamp(),ref.getStamp()+1));
                log.debug("版本 {}",ref.getStamp());
            },"t2").start();
        }
    
    }

输出为：

16:08:56.826 c.Test29 [main] - main start...
    16:08:56.828 c.Test29 [main] - 版本 0
    16:08:56.864 c.Test29 [t1] - change A->B true
    16:08:56.864 c.Test29 [t1] - 版本 1
    16:08:57.373 c.Test29 [t2] - change B->A true
    16:08:57.373 c.Test29 [t2] - 版本 2
    16:08:58.386 c.Test29 [main] - change A->C false

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

\*\*改进：\*\*但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，所以就有了`AtomicMarkableReference`

**3. AtomicMarkableReference**

AtomicMarkableReference 可以不关心引用变量的修改次数，只关心是否被修改过 ~ ~~

如下图：主人只关心 垃圾袋是否为空，并不关心垃圾袋被保洁倒了几次

![image-20220722161254008][]

**代码实现**

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 15:39
     */
    @Slf4j(topic = "c.Test30")
    public class Test30 {
        
        public static void main(String[] args) {
        
            GarbageBag bag = new GarbageBag("装满了垃圾");
            // 参数2 mark可以看做一个标记，表示垃圾装满了
            AtomicMarkableReference <GarbageBag> ref = new AtomicMarkableReference <>(bag, true);
    
            log.debug("start...");
            GarbageBag prev = ref.getReference();
            log.debug(prev.toString());
    
            new Thread(()->{
        
                log.debug("start...");
                bag.setDesc("空垃圾袋");
                ref.compareAndSet(bag,bag,true,false);
                log.debug(bag.toString());
            },"保洁阿姨").start();
    
            Sleeper.sleep(1);
            log.debug("想换一只新垃圾袋？");
            boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
            log.debug("换了么？"+success);
            log.debug(ref.getReference().toString());
        }
    }
    
    class GarbageBag {
        
        String desc;
    
        public GarbageBag(String desc) {
        
            this.desc = desc;
        }
    
        public void setDesc(String desc) {
        
            this.desc = desc;
        }
    
        @Override
        public String toString() {
        
            return super.toString() + " " + desc;
        }
    }

输出为：

16:17:12.629 c.Test30 [main] - start...
    16:17:12.631 c.Test30 [main] - com.rg.thread.GarbageBag@33e5ccce 装满了垃圾
    16:17:12.667 c.Test30 [保洁阿姨] - start...
    16:17:12.667 c.Test30 [保洁阿姨] - com.rg.thread.GarbageBag@33e5ccce 空垃圾袋
    16:17:13.671 c.Test30 [main] - 想换一只新垃圾袋？
    16:17:13.671 c.Test30 [main] - 换了么？false
    16:17:13.671 c.Test30 [main] - com.rg.thread.GarbageBag@33e5ccce 空垃圾袋

### 5.5 原子数组 ###

通过原子的方式，更新数组里的某个元素（修改元素的内容，而非元素的引用地址）

*  AtomicIntegerArray
 *  AtomicLongArray
 *  AtomicReferenceArray

注意：`compareAndSet()`的比较是通过引用地址比较的，之前是对String举例，String的不可变性导致了我们每次对String的更改也导致了引用的更改

代码演示：

public class Test31 {
        
    
        public static void main(String[] args) {
        
            // 普通数组
            demo(
                    ()->new int[10],
                    array->array.length,
                    (array,index)->array[index]++,
                    array->System.out.println(Arrays.toString(array))
            );
            //原子数组
            demo(
                    ()->new AtomicIntegerArray(10),
                    array->array.length(),
                    (array,index)->array.getAndIncrement(index),
                    array-> System.out.println(array)
            );
        }
    
        /**
         参数1，提供数组、可以是线程不安全数组或线程安全数组
         参数2，获取数组长度的方法
         参数3，自增方法，回传 array, index
         参数4，打印数组的方法
         */
        // supplier 提供者 无中生有  ()->结果
        // function 函数   一个参数一个结果   (参数)->结果  ,  BiFunction (参数1,参数2)->结果
        // consumer 消费者 一个参数没结果  (参数)->void,      BiConsumer (参数1,参数2)->
        private static <T> void demo(
                Supplier <T> arraySupplier,
                Function <T, Integer> lengthFun,
                BiConsumer <T, Integer> putConsumer,
                Consumer <T> printConsumer ) {
        
            List <Thread> ts = new ArrayList <>();
            T array = arraySupplier.get();
            int length = lengthFun.apply(array);
            for (int i = 0; i < length; i++) {
        // 10个线程 10000 自增操作，最终每个线程的值应该都是10000
                // 每个线程对数组作 10000 次操作
                ts.add(new Thread(() -> {
        
                    for (int j = 0; j < 10000; j++) {
        
                        putConsumer.accept(array, j%length);
                    }
                }));
            }
    
            ts.forEach(t -> t.start()); // 启动所有线程
            ts.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });     // 等所有线程结束
            printConsumer.accept(array);
        }
    }

输出为：

[9984, 9983, 9979, 9985, 9985, 9985, 9985, 9982, 9982, 9986] //普通数组
    [10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]//原子数组

### 5.6 字段更新器 ###

用于保证多个线程访问对象时，保证成员变量（属性）的安全性

*  AtomicReferenceFieldUpdater // 域 字段是引用类型
 *  AtomicIntegerFieldUpdater //字段时Integer类型
 *  AtomicLongFieldUpdater //字段时Long类型

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

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 17:21
     */
    @Slf4j(topic = "c.Test32")
    public class Test32 {
        
        public static void main(String[] args) {
        
            Student student = new Student();
            AtomicReferenceFieldUpdater <Student, String> updater = AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
            System.out.println(updater.compareAndSet(student,null,"张三"));
            System.out.println(student);
        }
    }
    
    class Student {
        
        //字段一定要用volatile修饰哦，否则会报异常
        volatile String name;
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

### 5.7 原子累加器 ###

#### 5.7.1 累加器性能比较 ####

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 17:27
     */
    @Slf4j(topic = "c.Test33")
    public class Test33 {
        
        public static void main(String[] args) {
        
            demo(
                    ()->new AtomicLong(0),
                    adder->adder.getAndIncrement()
            ); 
            demo(
                    ()->new LongAdder(),
                    adder->adder.increment()
            );
        }
        /*
       () -> 结果    提供累加器对象
       (参数) ->     执行累加操作
        */
        private static <T> void demo(Supplier <T> adderSupplier, Consumer <T> action) {
        
            T adder = adderSupplier.get();
            List <Thread> ts = new ArrayList <>();
            // 4 个线程，每人累加 50 万
            for (int i = 0; i < 4; i++) {
        
                ts.add(new Thread(() -> {
        
                    for (int j = 0; j < 500000; j++) {
        
                        action.accept(adder);
                    }
                }));
            }
            long start = System.nanoTime();
            ts.forEach(t -> t.start());
            ts.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
    
            long end = System.nanoTime();
            System.out.println(adder + " cost:" + (end - start) / 1000_000);
        }
    }

输出为：

2000000 cost:32
    2000000 cost:14

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

#### \* 源码之 LongAdder ####

LongAdder 是并发大师 @author Doug Lea （大哥李）的作品，设计的非常精巧  
LongAdder 类有几个关键域

// 累加单元数组, 懒惰初始化
    transient volatile Cell[] cells;
    // 基础值, 如果没有竞争, 则用 cas 累加这个域
    transient volatile long base;
    // 在 cells 创建或扩容时, 置为 1, 表示加锁
    transient volatile int cellsBusy;

注意：volatile保证共享变量的可见性，transient保证序列化下这些属性信息不会被序列化

#### 5.7.2 CAS锁 ####

//使用CAS实现Lock
    //不推荐使用：因为会造成CPU的空转...
    @Slf4j(topic = "c.Test42")
    public class LockCas {
        
        // 0 没加锁
        // 1 加锁
        private AtomicInteger state = new AtomicInteger(0);
    
        public void lock() {
        
            while (true) {
        
                if (state.compareAndSet(0, 1)) {
        
                    break;
                }
            }
        }
    
        public void unlock() {
        
            log.debug("unlock...");
            state.set(0);
        }
    
        public static void main(String[] args) {
        
            LockCas lock = new LockCas();
            new Thread(() -> {
        
                log.debug("begin...");
                lock.lock();
                try {
        
                    log.debug("lock...");
                    sleep(1);
                } finally {
        
                    lock.unlock();
                }
            }).start();
    
            new Thread(() -> {
        
                log.debug("begin...");
                lock.lock();
                try {
        
                    log.debug("lock...");
                } finally {
        
                    lock.unlock();
                }
            }).start();
        }
    }

输出为：

16:35:41.029 c.Test42 [Thread-1] - begin...
    16:35:41.028 c.Test42 [Thread-0] - begin...
    16:35:41.032 c.Test42 [Thread-1] - lock...
    16:35:41.032 c.Test42 [Thread-1] - unlock...
    16:35:41.032 c.Test42 [Thread-0] - lock...
    16:35:42.040 c.Test42 [Thread-0] - unlock...

#### \* 原理之伪共享 ####

其中 Cell 即为累加单元

// 防止缓存行伪共享
    @sun.misc.Contended
    static final class Cell {
        
        volatile long value;
        Cell(long x) {
         value = x; }
        // 最重要的方法, 用来 cas 方式进行累加, prev 表示旧值, next 表示新值
        final boolean cas(long prev, long next) {
        
            return UNSAFE.compareAndSwapLong(this, valueOffset, prev, next);
        }
    	// 省略不重要代码
    }

关于缓存行伪共享，得从缓存说起~ ~~

1. **缓存与内存的速度比较**

![image-20220723165156108][]

<table> 
 <thead> 
  <tr> 
   <th align="center">从 cpu 到</th> 
   <th align="center">大约需要的时钟周期</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">寄存器</td> 
   <td align="center">1 cycle (4GHz 的 CPU 约为0.25ns)</td> 
  </tr> 
  <tr> 
   <td align="center">L1</td> 
   <td align="center">3~4 cycle</td> 
  </tr> 
  <tr> 
   <td align="center">L2</td> 
   <td align="center">10~20 cycle</td> 
  </tr> 
  <tr> 
   <td align="center">L3</td> 
   <td align="center">40~45 cycle</td> 
  </tr> 
  <tr> 
   <td align="center">内存</td> 
   <td align="center">120~240 cycle</td> 
  </tr> 
 </tbody> 
</table>

因为 CPU 与 内存的速度差异很大，需要靠预读数据至缓存来提升效率。

而缓存以**缓存行**为单位，每个缓存行对应着一块内存，一般是 64 byte（8 个 long）

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

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

*  比如核心Core1和Core2都从内存中读入数据a = 2 到缓存中。之后Core1把数据改成了2000，此时为了保持数据的一致性，Core2中的数据也需要修改！即把Core2中的缓存行失效，重新去内存中取最新的数据

![image-20220723170038067][]

因为 Cell 是数组形式，在内存中是连续存储的，一个 Cell 为 24 字节（16 字节的对象头和 8 字节的 value），因此缓存行可以存下 2 个的 Cell 对象（1行64个字节）。这样问题来了：

*  Core-0 要修改 Cell\[0\]
 *  Core-1 要修改 Cell\[1\]

无论谁修改成功，都会导致对方 Core 的缓存行失效，比如 Core-0 中 `Cell[0]=6000, Cell[1]=8000`要修改为Cell\[0\]=6001, Cell\[1\]=8000 ，这时会让 Core-1 的缓存行失效

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

我们把一个缓存行加入了多个cell对象称为伪共享，注解的作用就是防止伪共享

![image-20220723170405289][]

累加主要调用下面的方法

**2. add()方法**

public void add(long x) {
        
        // as 为累加单元数组
        // b 为基础值
        // x 为累加值
        Cell[] as;
        long b, v;
        int m;
        Cell a;
        // 进入 if 的两个条件
        // 1. as 有值, 表示已经发生过竞争, 进入 if
        // 2. cas 给 base 累加时失败了, 表示 base 发生了竞争, 进入 if
        if ((as = cells) != null || !casBase(b = base, b + x)) {
        
            // uncontended 表示 cell 没有竞争
            boolean uncontended = true;
            if (
                // as 还没有创建
                as == null || (m = as.length - 1) < 0 ||
                // 当前线程对应的 cell 还没有
                (a = as[getProbe() & m]) == null ||
                // cas 给当前线程的 cell 累加失败 uncontended=false ( a 为当前线程的 cell )
                !(uncontended = a.cas(v = a.value, v + x))
            ) {
        
                // 进入 cell 数组创建、cell 创建的流程
                longAccumulate(x, null, uncontended);
            }
        }
    }

add流程图

![image-20220723182804979][]

**3. longAccumulate()**

final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) {
        
        int h;
        // 当前线程还没有对应的 cell, 需要随机生成一个 h 值用来将当前线程绑定到 cell
        if ((h = getProbe()) == 0) {
        
            // 初始化 probe
            ThreadLocalRandom.current();
            // h 对应新的 probe 值, 用来对应 cell
            h = getProbe();
            wasUncontended = true;
        }
        // collide 为 true 表示需要扩容
        boolean collide = false;
        for (; ; ) {
        
            Cell[] as;
            Cell a;
            int n;
            long v;
            // 已经有了 cells
            if ((as = cells) != null && (n = as.length) > 0) {
        
                // cells存在，但是里面还没有 cell
                if ((a = as[(n - 1) & h]) == null) {
        
                   //如果cellsBusy没有加锁，为 cellsBusy 加锁, 创建 cell
                    if (cellsBusy == 0) {
               // Try to attach new Cell
                         // 创建cell,且cell 的初始累加值为 x
                        Cell r = new Cell(x);   // Optimistically create
                        if (cellsBusy == 0 && casCellsBusy()) {
        //进行加锁，并修改cellsBusy=1
                            boolean created = false;
                            try {
                       // Recheck under lock
                                Cell[] rs; int m, j;
                                if ((rs = cells) != null &&//判断槽位是否为空
                                    (m = rs.length) > 0 &&
                                    rs[j = (m - 1) & h] == null) {
        //不为空则进行下一次循环尝试
                                    rs[j] = r;//为空，则将元素放到槽位上去
                                    created = true;
                                }
                            } finally {
        
                                cellsBusy = 0;
                            }
                            if (created)//如果上面cell创建成功，则退出
                                break;
                            continue;           // Slot is now non-empty
                        }
                    // 成功则 break, 否则继续 continue 循环
                }
                // 有竞争, 改变线程对应的 cell 来重试 cas
                else if (!wasUncontended)
                    wasUncontended = true;
                // cas 尝试累加, fn 配合 LongAccumulator 不为 null, 配合 LongAdder 为 null
                else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
                    break;
                // 如果 cells 长度已经超过了最大长度（CPU的核数）, 或者已经扩容, 改变线程对应的 cell 来重试 cas
                else if (n >= NCPU || cells != as)
                    collide = false;
                // 确保 collide 为 false 进入此分支, 就不会进入最后的 else if 进行扩容了
                else if (!collide)
                    collide = true;
                //修改标志位进行加锁
                else if (cellsBusy == 0 && casCellsBusy()) {
        
                    // 加锁成功, 扩容
                    try {
        
                        if (cells == as) {
              // 扩容cells
                            Cell[] rs = new Cell[n << 1];
                            for (int i = 0; i < n; ++i)
                                rs[i] = as[i];
                            cells = rs;
                        }
                    } finally {
        
                        cellsBusy = 0;
                    }
                    collide = false;
                    continue;        
                }
                // 改变线程对应的 cell，再重新循环
                h = advanceProbe(h);
            }
            // 还没有 cells, 尝试给 cellsBusy 加锁
            //cellsBusy == 0表示还没有其他线程为其加锁
            //cells == as表示还有没其他线程创建该cells数组（未新建）
            //casCellsBusy() 采用CAS方法将cellsBusy 从0 改为 1。这样做是为了防止其他线程也对其进行加锁..
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
        
                boolean init = false;
                // 加锁成功, 创建 cell数组, 最开始长度为 2。 并创建一个累加单元 cell
                try {
                                   // Initialize table
                    if (cells == as) {
        
                        Cell[] rs = new Cell[2];
                        //注意：虽然我们创建的Cell数组大小是2，但是我们只向其加入了一个元素，
                        //不到万不得已不创建另外一个cell，懒惰化的思想~~~
                        rs[h & 1] = new Cell(x);
                        cells = rs;//赋值给cells
                        init = true;
                    }
                } finally {
        //标志位设置为0，也就是解锁
                    cellsBusy = 0;
                }
                // 成功则 break，退出循环;
                if (init)
                    break;
            }
            // 上两种情况失败（如加锁失败）, 尝试给 base 累加，如果失败则重新循环
            else if (casBase(v = base, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
                break;
        }
    }

longAccumulate 流程图

![cca3a6782b3859573ffcbb22ee5e8bdb.png][]

![f6a47ebd2d867eabdcea54d461eece3a.png][]

每个线程刚进入 longAccumulate 时，会尝试对应一个 cell 对象（找到一个坑位）

![fcc4d182cb63b96fd08a8762f77e1663.png][]

**4. 获取最终结果通过 sum 方法**

//对cells数组的元素进行累加
    public long sum() {
        
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) {
        
            for (int i = 0; i < as.length; ++i) {
        
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

### 5.8 Unsafe ###

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

> unsafe 与线程安全性无关。因为比较接近底层，用来操作内存、线程，不建议我们直接使用

#### 5.8.1 Unsafe CAS 操作 ####

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 17:47
     */
    @Slf4j(topic = "c.TestUnsafe")
    public class TestUnsafe {
        
        public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        
            //使用反射获取到Unsafe对象
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            Unsafe unsafe = (Unsafe) theUnsafe.get(null);
    
            System.out.println(unsafe);
    
            //1. 获取域的偏移地址
            long idOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("id"));
            long nameOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("name"));
    
            Teacher teacher = new Teacher();
            //2. 执行cas操作
            unsafe.compareAndSwapInt(teacher,idOffset,0,1);
            unsafe.compareAndSwapObject(teacher,nameOffset,null,"张三");
    
            //3. 验证
            System.out.println(teacher);
        }
    }
    
    @Data
    class Teacher{
        
        volatile int id;
        volatile String name;
    }

输出为：

sun.misc.Unsafe@490d6c15
    Teacher(id=1, name=张三)

#### 6.8.2 unsafe对象模拟实现原子整数 ####

使用自定义的 MyAtomicInteger 实现之前线程安全的原子整数类 AtomicInteger

/**
     * @author lxy
     * @version 1.0
     * @Description
     * @date 2022/7/22 18:13
     */
    public class Test35 {
        
        public static void main(String[] args) {
        
            Account.demo(new MyAtomicInteger(10000));
        }
    }
    
    
    class MyAtomicInteger implements Account {
        
        private volatile int value;
        private static final long valueOffset;
        private static final Unsafe UNSAFE;
    
        public MyAtomicInteger(int value) {
        
            this.value = value;
        }
    
        static {
        
            UNSAFE = UnsafeAccessor.getUnsafe();
            try {
        
                valueOffset = UNSAFE.objectFieldOffset(MyAtomicInteger.class.getDeclaredField("value"));
            } catch (NoSuchFieldException e) {
        
                e.printStackTrace();
                throw new RuntimeException();
            }
        }
    
        private int getValue(){
        
            return value;
        }
    
        public void decrement(int amount){
        
            while (true){
        
                int prev = this.value;
                int next = prev-amount;
                if(UNSAFE.compareAndSwapInt(this,valueOffset,prev,next)){
        
                    break;
                }
            }
        }
    
        @Override
        public Integer getBalance() {
        
            return getValue();
        }
    
        @Override
        public void withdraw(Integer amount) {
        
            decrement(amount);
        }
    }
    
    interface Account {
        
        // 获取余额
        Integer getBalance();
    
        // 取款
        void withdraw(Integer amount);
    
        /**
         * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
         * 如果初始余额为 10000 那么正确的结果应当是 0
         */
        static void demo(Account account) {
        
            List <Thread> ts = new ArrayList <>();
            for (int i = 0; i < 1000; i++) {
        
                ts.add(new Thread(() -> {
        
                    account.withdraw(10);
                }));
            }
            long start = System.nanoTime();
            ts.forEach(Thread::start);
            ts.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            long end = System.nanoTime();
            System.out.println(account.getBalance()
                    + " cost: " + (end-start)/1000_000 + " ms");
        }
    }

### 本章小结 ###

*  CAS 与 volatile
 *  API
    
     *  原子整数
     *  原子引用
     *  原子数组
     *  字段更新器
     *  原子累加器
 *  Unsafe

*   *原理方面*\*
    
     *  LongAdder 源码
     *  伪共享

[image-20220716155350971]: https://img-blog.csdnimg.cn/img_convert/4f50411a5c5f4abe4723e4c8f69c50b8.png
[image-20220716171451791]: https://img-blog.csdnimg.cn/img_convert/b861affeab97365e0b239b0acded1518.png
[28851772d182388bf995526a17bfdd5d.png]: https://img-blog.csdnimg.cn/img_convert/28851772d182388bf995526a17bfdd5d.png
[image-20220716231350601]: https://img-blog.csdnimg.cn/img_convert/96ec2c59ca23b79b50e666ff0f84ca7f.png
[image-20220722161254008]: https://img-blog.csdnimg.cn/img_convert/fcf71094ee146b2d1891aa78315de9c6.png
[image-20220723165156108]: https://img-blog.csdnimg.cn/img_convert/c624fa5f78e65c4dd2dd0dd7365ae362.png
[image-20220723170038067]: https://img-blog.csdnimg.cn/img_convert/38671cdb3f38c450d4700bfe20ac9f91.png
[image-20220723170405289]: https://img-blog.csdnimg.cn/img_convert/bb055422607e760bbdde607e2b6cc00f.png
[image-20220723182804979]: https://img-blog.csdnimg.cn/img_convert/4aa71d24e219a078b9e23923ff99f157.png
[cca3a6782b3859573ffcbb22ee5e8bdb.png]: https://img-blog.csdnimg.cn/img_convert/cca3a6782b3859573ffcbb22ee5e8bdb.png
[f6a47ebd2d867eabdcea54d461eece3a.png]: https://img-blog.csdnimg.cn/img_convert/f6a47ebd2d867eabdcea54d461eece3a.png
[fcc4d182cb63b96fd08a8762f77e1663.png]: https://img-blog.csdnimg.cn/img_convert/fcc4d182cb63b96fd08a8762f77e1663.png