Java并发编程(七) : CAS概念、原子操作类(乐观锁思想)、LongAddr和AtomicLong、Unsafe

Myth丶恋晨 2022-12-30 10:41 25阅读 0赞

# 一、 共享模型之无锁 #

>  *  Java中 **synchronized** 和 **ReentrantLock** 等 独占锁 就是 **`悲观锁`** 思想的实现
>  *  在Java中**java.util.concurrent.atomic包下面的原子变量类**就是使用了`乐观锁`的一种实现方式 **`CAS`** 实现的

*  管程即`monitor`是`阻塞式的悲观锁`实现`并发控制`，这章我们将通过`非阻塞式的乐观锁`的来实现`并发控制`

## 1、 问题提出 ##

*  有如下需求，保证`account.withdraw取款方法`的线程安全, 下面使用`synchronized`保证线程安全

/** * Description: 使用重量级锁synchronized来保证多线程访问共享资源发生的安全问题 * * @author guizy * @date 2020/12/27 16:23 */
    @Slf4j(topic = "guizy.Test1")
    public class Test1 { 
    
        public static void main(String[] args) { 
            Account.demo(new AccountUnsafe(10000));
            Account.demo(new AccountCas(10000));
        }
    }
    
    class AccountUnsafe implements Account { 
        private Integer balance;
    
        public AccountUnsafe(Integer balance) { 
            this.balance = balance;
        }
    
        @Override
        public Integer getBalance() { 
            synchronized (this) { 
                return balance;
            }
        }
    
        @Override
        public void withdraw(Integer amount) { 
            // 通过这里加锁就可以实现线程安全，不加就会导致线程安全问题
            synchronized (this) { 
                balance -= amount;
            }
        }
    }
    
    
    interface Account { 
        // 获取余额
        Integer getBalance();
    
        // 取款
        void withdraw(Integer amount);
    
        /** * Java8之后接口新特性, 可以添加默认方法 * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作 * 如果初始余额为 10000 那么正确的结果应当是 0 */
        static void demo(Account account) { 
            List<Thread> ts = new ArrayList<>();
            long start = System.nanoTime();
            for (int i = 0; i < 1000; i++) { 
                ts.add(new Thread(() -> { 
                    account.withdraw(10);
                }));
            }
            ts.forEach(thread -> 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");
        }
    }

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

*  上面的代码中使用`synchronized加锁`操作来`保证线程安全`，但是 **synchronized加锁操作太耗费资源 (因为底层使用了操作系统mutex指令, 造成内核态和用户态的切换)**，这里我们使用 **`无锁`** 来解决此问题

class AccountCas implements Account { 
    	//使用原子整数: 底层使用CAS+重试的机制
    	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;
    			//比较并设置值
    			/* 此时的prev为共享变量的值, 如果prev被别的线程改了.也就是说: 自己读到的共享变量的值 和 共享变量最新值 不匹配, 就继续where(true),如果匹配上了, 将next值设置给共享变量. AtomicInteger中value属性, 被volatile修饰, 就是为了确保线程之间共享变量的可见性. */
    			if(balance.compareAndSet(prev, next)) { 
    				break;
    			}
    		}
    	}
    }

## 3、 CAS 与 volatile `(重点)` ##

> 使用原子操作来保证线程访问共享资源的安全性, cas+重试的机制来确保(乐观锁思想), 相对于悲观锁思想的`synchronized,reentrantLock`来说, cas的方式效率会更好!

### 3.1、cas + 重试 的原理 ###

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

@Override
    public void withdraw(Integer amount) { 
        // 核心代码
        // 需要不断尝试，直到成功为止
        while (true){ 
            // 比如拿到了旧值 1000
            int prev = balance.get();
            // 在这个基础上 1000-10 = 990
            int next = prev - amount;
            /* compareAndSet 保证操作共享变量安全性的操作: ① 线程A首先获取balance.get(),拿到当前的balance值prev ② 根据这个prev值 - amount值 = 修改后的值next ③ 调用compareAndSet方法, 首先会判断当初拿到的prev值,是否和现在的 balance值相同; 3.1、如果相同,表示其他线程没有修改balance的值, 此时就可以将next值 设置给balance属性 3.2、如果不相同,表示其他线程也修改了balance值, 此时就设置next值失败, 然后一直重试, 重新获取balance.get()的值,计算出next值, 并判断本次的prev和balnce的值是否相同...重复上面操作 */
            if (atomicInteger.compareAndSet(prev,next)){ 
                break;
            }
        }
    }

*  其中的关键是 `compareAndSwap（比较并设置值）`，它的简称就是 `CAS` （也有 Compare And Swap 的说法），它必须是`原子操作`。

![1594776811158][]  
**流程 :**

*  当一个线程要去修改`Account对象`中的值时，`先获取值prev（调用get方法）`，然后再将其设置为新的值`next`（调用cas方法）。在调用cas方法时，会将`prev`与`Account中的余额`进行比较。
    
     *  如果两者`相等`，就说明该值还未被其他线程修改，此时便可以进行修改操作。
     *  如果两者`不相等`，就不设置值，重新获取值prev（调用get方法），然后再将其设置为新的值next（调用cas方法），直到修改成功为止。

**注意 :**

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

### 3.2、volatile的作用 ###

*  在上面代码中的`AtomicInteger类`，**保存值的`value属性`使用了`volatile 修饰`**。获取共享变量时，为了`保证该变量的可见性`，需要使用 **volatile 修饰**。
 *  volatile可以用来修饰 **`成员变量和静态成员变量`**，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。**`即一个线程对 volatile 变量的修改，对另一个线程可见。`**

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

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

### 3.3、为什么CAS+重试(无锁)效率高 ###

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

### 3.4、CAS 的特点 (乐观锁和悲观锁的特点) ###

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

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

## 4、原子整数 (内部通过CAS来实现-AtomicInteger) ##

*  `java.util.concurrent.atomic并发包`提供了一些并发工具类，这里把它分成五类：
 *  使用原子的方式 **(共享数据为基本数据类型原子类)**
    
     *  **`AtomicInteger：整型原子类`**
     *  AtomicLong：长整型原子类
     *  AtomicBoolean ：布尔型原子类
 *  上面三个类提供的方法几乎相同，所以我们将以 `AtomicInteger`为例子来介绍。  
    先讨论`原子整数类`，以 `AtomicInteger` 为例讨论它的api接口：通过观察源码可以发现
 *  **AtomicInteger 内部都是通过`cas的原理`来实现的**

public static void main(String[] args) { 
        AtomicInteger i = new AtomicInteger(0);
        
        // 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
        System.out.println(i.getAndIncrement());
        
        // 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
        System.out.println(i.incrementAndGet());
        
        // 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
        System.out.println(i.decrementAndGet());
        
        // 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
        System.out.println(i.getAndDecrement());
        
        // 获取并加值（i = 0, 结果 i = 5, 返回 0）
        System.out.println(i.getAndAdd(5));
        
        // 加值并获取（i = 5, 结果 i = 0, 返回 0）
        System.out.println(i.addAndGet(-5));
        
        // 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        System.out.println(i.getAndUpdate(p -> p - 2));
        
        // 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        System.out.println(i.updateAndGet(p -> p + 2));
        
        // 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        // getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
        // getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
        System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
        
        // 计算并获取（i = 10, p 为 i 的当前值, x 为参数1值, 结果 i = 0, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
    }

#### 举个例子: updateAndGet的实现 ####

public static void main(String[] args) { 
    
    	AtomicInteger i = new AtomicInteger(5);
    	
        updateAndGet(i, new IntUnaryOperator() { 
            @Override
            public int applyAsInt(int operand) { 
                return operand / 2;
            }
        });
        System.out.println(i.get()); // 2
    }
    
    public static void updateAndGet(AtomicInteger i, IntUnaryOperator operator) { 
        while (true) { 
            int prev = i.get(); // 5
            int next = operator.applyAsInt(prev);
            if (i.compareAndSet(prev, next)) { 
                break;
            }
        }
    }

步骤:

*  调用`updateAndGet`方法, 将`共享变量i`, `IntUnaryOperator对象`传递过去
 *  updateAndGet方法内部, 传过来的`operator`对象, 调用`IntUnaryOperator中的applyAsInt`方法, 实际调用的就是`传递过来的对象的方法, 进行 / 操作`  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]

## 5、原子引用 (AtomicReference) ##

> 原子引用的作用: **保证引用类型的共享变量是线程安全的(确保这个原子引用没有引用过别人)**

*  为什么需要原子引用类型 ? (引用数据类型原子类)
    
     *  `AtomicReference`
     *  `AtomicMarkableReference`
     *  `AtomicStampedReference` **(可以解决ABA问题)**

为什么需要`原子引用类型`？**保证`引用类型的共享变量是线程安全`的（确保这个原子引用没有引用过别人）。**

基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用引用类型原子类。

*  **AtomicReference**：引用类型原子类
 *  **AtomicStampedReference**：原子更新带有`版本号`的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，**`可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。`**
 *  **AtomicMarkableReference** ：原子更新带有`标记`的引用类型。该类将 boolean 标记与引用关联起来，也可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

例子 : 使用原子引用实现BigDecimal存取款的线程安全：

下面这个是不安全的实现过程：

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);
        }
    }

解决代码如下：在`AtomicReference类`中，存在一个value类型的变量，保存对BigDecimal对象的引用。

public class Test1 { 
    
        public static void main(String[] args) { 
            DecimalAccount.demo(new DecimalAccountCas(new BigDecimal("10000")));
        }
    }
    
    class DecimalAccountCas implements DecimalAccount { 
    
        //原子引用，泛型类型为小数类型
        private final 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;
                }
            }
        }
    }
    
    
    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());
        }
    }

### ABA 问题及解决 (`重点`) ###

*  如下程序所示，虽然 **在other方法中存在两个线程对共享变量进行了修改，但是修改之后又变成了原值**，**main线程对`修改过共享变量的过程`是不可见的，这种操作这对业务代码并无影响。**

public class Test1 { 
    
        static AtomicReference<String> ref = new AtomicReference<>("A");
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                String pre = ref.get();
                System.out.println("change");
                try { 
                    other();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                Sleeper.sleep(1);
                //把ref中的A改为C
                System.out.println("change A->C " + ref.compareAndSet(pre, "C"));
            }).start();
        }
    
        static void other() throws InterruptedException { 
            new Thread(() -> { 
            	// 此时ref.get()为A,此时共享变量ref也是A,没有被改过, 此时CAS
            	// 可以修改成功, B
                System.out.println("change A->B " + ref.compareAndSet(ref.get(), "B"));
            }).start();
            Thread.sleep(500);
            new Thread(() -> { 
            	// 同上, 修改为A
                System.out.println("change B->A " + ref.compareAndSet(ref.get(), "A"));
            }).start();
        }
    }

![在这里插入图片描述][20201227200916774.png]

*  主线程仅能判断出`共享变量的值`与`最初值 A`是否相同，不能感知到这种从 A 改为 B 又改回 A 的情况，如果主线程希望：**只要有其它线程【动过】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个`版本号`。使用`AtomicStampedReference`来解决。**

### AtomicStampedReference (加版本号解决ABA问题) ###

*  解决ABA问题

public class Test1 { 
        //指定版本号
        static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                String pre = ref.getReference();
                //获得版本号
                int stamp = ref.getStamp(); // 此时的版本号还是第一次获取的
                System.out.println("change");
                try { 
                    other();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                //把ref中的A改为C,并比对版本号，如果版本号相同，就执行替换，并让版本号+1
                System.out.println("change A->C stamp " + stamp + ref.compareAndSet(pre, "C", stamp, stamp + 1));
            }).start();
        }
    
        static void other() throws InterruptedException { 
            new Thread(() -> { 
                int stamp = ref.getStamp();
                System.out.println("change A->B stamp " + stamp + ref.compareAndSet(ref.getReference(), "B", stamp, stamp + 1));
            }).start();
            Thread.sleep(500);
            new Thread(() -> { 
                int stamp = ref.getStamp();
                System.out.println("change B->A stamp " + stamp + ref.compareAndSet(ref.getReference(), "A", stamp, stamp + 1));
            }).start();
        }
    }

![在这里插入图片描述][20201227201334161.png]

### AtomicMarkableReference (标记cas的共享变量是否被修改过) ###

*  `AtomicStampedReference` 可以给`原子引用`加上`版本号`，**追踪原子引用整个的变化过程**，如：A -> B -> A ->C，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。
 *  但是有时候，`并不关心引用变量更改了几次，只是单纯的关心是否更改过`，所以就有了`AtomicMarkableReference`

![1594803309714][]

@Slf4j(topic = "guizy.TestABAAtomicMarkableReference")
    public class TestABAAtomicMarkableReference { 
        public static void main(String[] args) throws InterruptedException { 
            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("空垃圾袋");
                while (!ref.compareAndSet(bag, bag, true, false)) { 
                }
                log.debug(bag.toString());
            }).start();
            
            Thread.sleep(1000);
            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;
        }
    }

23:00:24.062 guizy.TestABAAtomicMarkableReference [main] - 主线程 start...
    23:00:24.069 guizy.TestABAAtomicMarkableReference [main] - com.guizy.cas.GarbageBag@2be94b0f 装满了垃圾
    23:00:24.312 guizy.TestABAAtomicMarkableReference [Thread-0] - 打扫卫生的线程 start...
    23:00:24.313 guizy.TestABAAtomicMarkableReference [Thread-0] - com.guizy.cas.GarbageBag@2be94b0f 空垃圾袋
    23:00:25.313 guizy.TestABAAtomicMarkableReference [main] - 主线程想换一只新垃圾袋？
    23:00:25.314 guizy.TestABAAtomicMarkableReference [main] - 换了么？false
    23:00:25.314 guizy.TestABAAtomicMarkableReference [main] - com.guizy.cas.GarbageBag@2be94b0f 空垃圾袋

举例2:

public class Test1 { 
        //指定版本号
        static AtomicMarkableReference<String> ref = new AtomicMarkableReference<>("A", true);
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                String pre = ref.getReference();
                System.out.println("change");
                try { 
                    other();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                //把str中的A改为C,并比对版本号，如果版本号相同，就执行替换，并让版本号+1
                System.out.println("change A->C mark " + ref.compareAndSet(pre, "C", true, false));
            }).start();
        }
    
        static void other() throws InterruptedException { 
            new Thread(() -> { 
                System.out.println("change A->A mark " + ref.compareAndSet(ref.getReference(), "A", true, false));
            }).start();
        }
    }

![在这里插入图片描述][20201227201642314.png]

### AtomicStampedReference和AtomicMarkableReference两者的区别 ###

*  **`AtomicStampedReference`** 需要我们传入 **`整型变量`** 作为`版本号`，来判定是否被更改过
 *  **`AtomicMarkableReference`需要我们传入`布尔变量`** 作为`标记`，来判断是否被更改过

## 6、原子数组 (AtomicIntegerArray) ##

*  保证数组内的元素的`线程安全`
 *  使用原子的方式更新数组里的某个元素
    
     *  `AtomicIntegerArray`：整形数组原子类
     *  `AtomicLongArray`：长整形数组原子类
     *  `AtomicReferenceArray`：引用类型数组原子类

上面三个类提供的方法几乎相同，所以我们这里以 `AtomicIntegerArray` 为例子来介绍。实例代码

*  普通数组内元素, 多线程访问造成安全问题

public class AtomicArrayTest { 
        public static void main(String[] args) { 
            demo(
                    () -> new int[10],
                    array -> array.length,
                    (array, index) -> array[index]++,
                    array -> System.out.println(Arrays.toString(array))
            );
        }
    
        /** * 参数1，提供数组、可以是线程不安全数组或线程安全数组 * 参数2，获取数组长度的方法 * 参数3，自增方法，回传 array, index * 参数4，打印数组的方法 */
        // supplier 提供者 无中生有 ()->结果
        // function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
        // consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->void
        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 次操作
                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);
        }
    }

[9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698]

*  使用`AtomicIntegerArray`来创建安全数组

demo(
            ()-> new AtomicIntegerArray(10),
            (array) -> array.length(),
            (array, index) -> array.getAndIncrement(index),
            array -> System.out.println(array)
    );
    
    demo(
            ()-> new AtomicIntegerArray(10),
            AtomicIntegerArray::length,
            AtomicIntegerArray::getAndIncrement,
            System.out::println
    );

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

## 7、字段更新器 ##

保证`多线程`访问`同一个对象的成员变量`时, `成员变量的线程安全性`。

*  `AtomicReferenceFieldUpdater` —引用类型的属性
 *  AtomicIntegerFieldUpdater —整形的属性
 *  AtomicLongFieldUpdater —长整形的属性

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

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

*  例子

@Slf4j(topic = "guizy.AtomicFieldTest")
    public class AtomicFieldTest { 
        public static void main(String[] args) { 
            Student stu = new Student();
            // 获得原子更新器
          	// 泛型
          	// 参数1 持有属性的类 参数2 被更新的属性的类
          	// newUpdater中的参数：第三个为属性的名称
            AtomicReferenceFieldUpdater updater = AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
            // 期望的为null, 如果name属性没有被别的线程更改过, 默认就为null, 此时匹配, 就可以设置name为张三
            System.out.println(updater.compareAndSet(stu, null, "张三"));
            System.out.println(updater.compareAndSet(stu, stu.name, "王五"));
            System.out.println(stu);
        }
    }
    
    class Student { 
        volatile String name;
    
        @Override
        public String toString() { 
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

true
    true
    Student{ name='王五'}

## 8、原子累加器 (LongAddr) (`重要`) ##

*  `LongAddr`
 *  LongAccumulator
 *  DoubleAddr
 *  DoubleAccumulator

##### `累加器性能比较 AtomicLong, LongAddr` #####

@Slf4j(topic = "guizy.Test")
    public class Test { 
        public static void main(String[] args) { 
            System.out.println("----AtomicLong----");
            for (int i = 0; i < 5; i++) { 
                demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
            }
    
            System.out.println("----LongAdder----");
            for (int i = 0; i < 5; i++) { 
                demo(() -> new LongAdder(), adder -> adder.increment());
            }
        }
    
        private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) { 
            T adder = adderSupplier.get();
            long start = System.nanoTime();
            List<Thread> ts = new ArrayList<>();
            // 4 个线程，每人累加 50 万
            for (int i = 0; i < 40; i++) { 
                ts.add(new Thread(() -> { 
                    for (int j = 0; j < 500000; j++) { 
                        action.accept(adder);
                    }
                }));
            }
            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);
        }
    }

----AtomicLong----
    20000000 cost:646
    20000000 cost:707
    20000000 cost:689
    20000000 cost:713
    20000000 cost:657
    ----LongAdder----
    20000000 cost:148
    20000000 cost:139
    20000000 cost:130
    20000000 cost:122
    20000000 cost:116

LongAddr

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

AtomicLong

*  **之前AtomicLong等都是在一个`共享资源变量`上进行竞争, `while(true)`循环进行CAS重试, 性能没有`LongAdder`高**

## 9、LongAdder原理 (了解) ##

#### 原理之伪共享 ####

[![img][]][img 1]

*  缓存行伪共享得从`缓存`说起
 *  缓存与内存的速度比较

[![img][img 2]][img_img 2]

[![img][img 3]][img_img 3]

*  因为 `CPU 与 内存的速度差异很大`，需要靠`预读数据`至**缓存**来提升效率。而缓存以**缓存行**为单位，每个缓存行对应着一块内存，一般是 **64 byte**（8 个 long）**缓存的加入会造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中**
 *  CPU 要保证数据的**一致性** (缓存一致性)，如果某个 CPU 核心**更改**了数据，其它 CPU 核心对应的整个缓存行必须**失效**

[![img][img 4]][img_img 4]

*  因为 Cell 是数组形式，在内存中是连续存储的，一个 Cell 为 24 字节（16 字节的对象头和 8 字节的 value），因 此缓存行可以存下 2 个的 Cell 对象。这样问题来了：
    
     *  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 将对象预读至缓存时**占用不同的缓存行**，这样，不会造成对方缓存行的失效

[![img][img 5]][img_img 5]

**累加主要调用以下方法**

public void add(long x) { 
           Cell[] as; long b, v; int m; Cell a;
           if ((as = cells) != null || !casBase(b = base, b + x)) { 
               boolean uncontended = true;
               if (as == null || (m = as.length - 1) < 0 ||
                   (a = as[getProbe() & m]) == null ||
                   !(uncontended = a.cas(v = a.value, v + x)))
                   longAccumulate(x, null, uncontended);
           }
       }

**累加流程图**

[![img][img 6]][img_img 6]

## 10、Unsafe (`重点`) ##

*  Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过`反射`获得
 *  可以发现`AtomicInteger`以及其他的原子类, 底层都使用的是`Unsafe`类  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]
 *  使用底层的`Unsafe`实现原子操作

public class Test { 
        public static void main(String[] args) throws Exception { 
            // 通过反射获得Unsafe对象
            Class unsafeClass = Unsafe.class;
            // 获得构造函数，Unsafe的构造函数为私有的
            Constructor constructor = unsafeClass.getDeclaredConstructor();
            // 设置为允许访问私有内容
            constructor.setAccessible(true);
            // 创建Unsafe对象
            Unsafe unsafe = (Unsafe) constructor.newInstance();
    
            // 创建Person对象
            Person person = new Person();
            // 获得其属性 name 的偏移量
            long nameOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("name"));
            long ageOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("age"));
    
            // 通过unsafe的CAS操作改变值
            unsafe.compareAndSwapObject(person, nameOffset, null, "guizy");
            unsafe.compareAndSwapInt(person, ageOffset, 0, 22);
            System.out.println(person);
        }
    }
    
    class Person { 
        // 配合CAS操作，必须用volatile修饰
        volatile String name;
        volatile int age;
        
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

[1594776811158]: /images/20221120/d273177e5d244ad99429aa38da5f31be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]: /images/20221120/514be6832fc6453ba83e3144f1df4135.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]: /images/20221120/cbcd5885365943269e825ef608452d13.png
[20201227200916774.png]: /images/20221120/5f21df8567554bf7becf37764b42b3c8.png
[20201227201334161.png]: /images/20221120/6afd918d9a7245558b821537ede33da9.png
[1594803309714]: /images/20221120/f5846d6fc0604881ba7d7e44686d5a57.png
[20201227201642314.png]: /images/20221120/64306ac904f84546a2eb20e4f8339697.png
[img]: https://img-blog.csdnimg.cn/img_convert/e1c53a0fb41d7d089e5ddcc71f1f2a0d.png
[img 1]: https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150037.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/9d3df3ad5311a92ecf235ccf78584ca3.png
[img_img 2]: https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150051.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/b4d95b0315026ad343cda2dd2d2f3c2a.png
[img_img 3]: https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150102.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/56de3a77bb6f96ba480f622083864c36.png
[img_img 4]: https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150111.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/4f0aefac3f7bfaece8703efa77e342fa.png
[img_img 5]: https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150119.png
[img 6]: https://img-blog.csdnimg.cn/img_convert/ce399f7bd72da53a22f6fbaba896dcc1.png
[img_img 6]: https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150129.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201228125739963.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70