第 2 章 JUC

╰半橙微兮° 2022-11-27 03:19 214阅读 0赞

# 第 2 章 JUC #

## 1、volatile 关键字 ##

> **谈谈你对volatile的理解**

### 1.1、volatile 三大特性 ###

> **volatile是java虚拟机提供的轻量级同步机制**

可以将 volatile 看作是乞丐版的 synchronized 锁

1.  保证内存可见性
2.  禁止指令重排
3.  不保证原子性

### 1.2、JMM 内存模型 ###

#### 1.2.1、谈谈 JMM ####

> **谈谈 JMM**

JMM（Java内存模型Java Memory Model，简称JMM）本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，**通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式**。

--------------------

**JMM关于同步的规定：**

1.  线程解锁前，必须把共享变量的值刷新回主内存
2.  线程加锁前，必须读取主内存的最新值到自己的工作内存
3.  加锁解锁是同一把锁

--------------------

**内存可见性**

1.  由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为**栈空间**），**工作内存是每个线程的私有数据区域**
2.  Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但**线程对变量的操作（读取赋值等）必须在工作内存中进行**
3.  一个线程如果想要修改主内存中的变量，**首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量**，各个线程中的工作内存中存储着**主内存中的变量副本拷贝**，因此不同的线程间无法访问对方的工作内存
4.  线程间的通信（传值）必须通过主内存来完成，其简要访问过程如下图：

![image-20200807104915773][]

#### 1.2.2、内存可见性 ####

> **JMM volatile 的内存可见性**

1.  通过前面对JMM的介绍，我们知道：各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后再写回到主内存中的
2.  这就可能存在一个线程AAA修改了共享变量X的值但还未写回主内存时，另外一个线程BBB又对主内存中同一个共享变量X进行操作
3.  但此时A线程工作内存中的共享变量X对线程B来说并不可见，这种**工作内存与主内存同步延迟现象就造成了可见性问题**

> **代码示例：内存可见性**

**代码示例 1 ：线程间内存不可见**

*  代码：number 变量未加 volatile 关键字

/**
     * @ClassName VolatileDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 10:59
     * @Version 1.0
     */
    public class VolatileDemo {
        
    
        public static void main(String[] args) {
        
            volatileVisibilityDemo();
        }
    
        /*
        验证volatile的可见性
            1.1 加入int number=0，number变量之前根本没有添加volatile关键字修饰，没有可见性
            1.2 添加了volatile，可以解决可见性问题
         */
        private static void volatileVisibilityDemo() {
        
            System.out.println("可见性测试");
            MyData myData = new MyData();//资源类
            
            //启动一个线程操作共享数据
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + "\t come in");
                try {
        
                    TimeUnit.SECONDS.sleep(3);
                    myData.setTo60();
                    System.out.println(Thread.currentThread().getName() + "\t update number value: " + myData.number);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }, "AAA").start();
    
            while (myData.number == 0) {
        
                //main线程持有共享数据的拷贝，一直为0
            }
            System.out.println(Thread.currentThread().getName() + "\t mission is over. main get number value: " + myData.number);
        }
    }
    
    
    class MyData {
        
    
        int number = 0;
    
        public void setTo60() {
        
            this.number = 60;
        }
    
    }

*  程序运行结果：程序未能停下来

![image-20200807112939904][]

*  分析：
    
     *  在上述程序中，两个线程：main 线程和 AAA 线程，同时对 myData 数据进行操作
     *  由于 AAA 线程先睡眠了 3s ，所以 main 线程先拿到了 myData.number 的值，将该值拷贝回自己线程的工作内存，此时 myData.number = 0
     *  AAA 线程 3s 后醒来，将 myData.number 拷贝回自己线程的工作内存，修改为 60 后，写回主内存
     *  但 AAA 线程将 myData.number 的值写回主内存后，并不会去通知 main 线程，所以 main 线程一直拿着自己线程的工作内存中的 myData.number = 0 ，搁那儿 while 循环呢

--------------------

**代码示例 2 ：volatile 保证线程间内存的可见性**

*  代码：number 变量加上 volatile 关键字

/**
     * @ClassName VolatileDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 10:59
     * @Version 1.0
     */
    public class VolatileDemo {
        
    
        public static void main(String[] args) {
        
            volatileVisibilityDemo();
        }
    
        /*
        验证volatile的可见性
            1.1 加入int number=0，number变量之前根本没有添加volatile关键字修饰，没有可见性
            1.2 添加了volatile，可以解决可见性问题
         */
        private static void volatileVisibilityDemo() {
        
            System.out.println("可见性测试");
            MyData myData = new MyData();//资源类
            //启动一个线程操作共享数据
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + "\t come in");
                try {
        
                    TimeUnit.SECONDS.sleep(3);
                    myData.setTo60();
                    System.out.println(Thread.currentThread().getName() + "\t update number value: " + myData.number);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }, "AAA").start();
    
            while (myData.number == 0) {
        
                //main 线程收到通知后，会修改自己线程内存中的值
            }
            System.out.println(Thread.currentThread().getName() + "\t mission is over. main get number value: " + myData.number);
        }
    }
    
    
    class MyData {
        
    
        // volatile可以保证可见性，及时通知其它线程主物理内存的值已被修改
        volatile int number = 0;
    
        public void setTo60() {
        
            this.number = 60;
        }
    
    }

*  程序运行结果：停下来了哦

![image-20200807114105344][]

*  分析：由于有volatile 关键字的存在，当 AAA 线程修改了 myData.number 的值后，main 线程会受到通知，从而刷新自己线程工作内存中的值

#### 1.2.3、原子性 ####

> **原子性是什么？**

**原子性是不可分割，完整性**。也即某个线程正在做某个具体业务时，中间不可以被加塞或者分割， 需要整体完成，**要么同时成功，要么同时失败**（类比数据库原子性）

> **代码示例：volatile 不保证原子性**

*  代码

/**
     * @ClassName VolatileDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 10:59
     * @Version 1.0
     */
    public class VolatileDemo {
        
    
        public static void main(String[] args) {
        
            atomicDemo();
        }
    
        /*
        2 验证volatile不保证原子性
            2.1 原子性是不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者分割。
                需要整体完成，要么同时成功，要么同时失败。
    
            2.2 volatile不可以保证原子性演示
    
            2.3 如何解决原子性
                1）加sync
                2）使用我们的JUC下AtomicInteger
         */
        private static void atomicDemo() {
        
            System.out.println("原子性测试");
            MyData myData = new MyData();
            for (int i = 1; i <= 20; i++) {
        
                new Thread(() -> {
        
                    for (int j = 0; j < 1000; j++) {
        
                        myData.addPlusPlus();
                    }
                }, String.valueOf(i)).start();
            }
            /*
            需要等待上述20个线程都计算完成后，再用main线程去的最终的结果是多少？
            只要上述20个线程还有在执行的，main线程便礼让，让他们执行，直至最后只剩main线程
             */
            while (Thread.activeCount() > 2) {
        
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "\t int type finally number value: " + myData.number);
        }
    }
    
    
    class MyData {
        
    
        // volatile可以保证可见性，及时通知其它线程主物理内存的值已被修改
        volatile int number = 0;
    
        public void setTo60() {
        
            this.number = 60;
        }
    
        //此时number前面已经加了volatile，但是不保证原子性
        public void addPlusPlus() {
        
            number++;
        }
    
    }

*  程序运行结果

原子性测试
    main	 int type finally number value: 19077

> **从字节码角度解释原子性**

*  java 源代码

/**
     * @ClassName T1
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 12:54
     * @Version 1.0
     */
    public class T1 {
        
    
        volatile int n = 0;
    
        public void add() {
        
            n++;
        }
    
    }

*  n++ 的字节码指令

0 aload_0
     1 dup
     2 getfield #2 <com/Heygo/T1.n>
     5 iconst_1
     6 iadd
     7 putfield #2 <com/Heygo/T1.n>
    10 return

--------------------

**n++ 分为三步**

1.  第一步：执行 getfield 指令拿到主内存中 n 的值
2.  第二步：执行 iadd 指令执行加 1 的操作（线程工作内存中的变量副本值加 1）
3.  第三步：执行 putfield 指令将累加后的 n 值写回主内存

PS ：iconst\_1 是将常量 1 放入操作数栈中，准备执行 iadd 操作

--------------------

**分析多线程写值，值丢失的原因**

1.  两个线程：线程 A和线程 B ，同时拿到主内存中 n 的值，并且都执行了加 1 的操作
2.  线程 A 先执行 putfield 指令将副本的值写回主内存，线程 B 在线程 A 之后也将副本的值写回主内存
3.  此时，就会出现写覆盖、丢失写值的情况

> **解决原子性问题：**

**两个解决办法：**

1.  对 addPlusPlus() 方法加同步锁（加锁这个解决方法太重）
2.  使用 **Java.util.concurrent.AtomicInteger** 类

--------------------

*  代码：使用 AtomicInteger 类保证 i++ 操作的原子性

/**
     * @ClassName VolatileDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 10:59
     * @Version 1.0
     */
    public class VolatileDemo {
        
    
        public static void main(String[] args) {
        
            atomicDemo();
        }
    
        /*
        2 验证volatile不保证原子性
            2.1 原子性是不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者分割。
                需要整体完成，要么同时成功，要么同时失败。
    
            2.2 volatile不可以保证原子性演示
    
            2.3 如何解决原子性
                1）加sync
                2）使用我们的JUC下AtomicInteger
         */
        private static void atomicDemo() {
        
            System.out.println("原子性测试");
            MyData myData = new MyData();
            for (int i = 1; i <= 20; i++) {
        
                new Thread(() -> {
        
                    for (int j = 0; j < 1000; j++) {
        
                        myData.addPlusPlus();
                        myData.addAtomic();
                    }
                }, String.valueOf(i)).start();
            }
            /*
            需要等待上述20个线程都计算完成后，再用main线程去的最终的结果是多少？
            只要上述20个线程还有在执行的，main线程便礼让，让他们执行，直至最后只剩main线程
             */
            while (Thread.activeCount() > 2) {
        
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "\t int type finally number value: " + myData.number);
            System.out.println(Thread.currentThread().getName() + "\t AtomicInteger type finally number value: " + myData.atomicInteger);
        }
    }
    
    
    class MyData {
        
    
        // volatile可以保证可见性，及时通知其它线程主物理内存的值已被修改
        volatile int number = 0;
    
        public void setTo60() {
        
            this.number = 60;
        }
    
        //此时number前面已经加了volatile，但是不保证原子性
        public void addPlusPlus() {
        
            number++;
        }
    
        // Integer 原子包装类
        AtomicInteger atomicInteger = new AtomicInteger();
    
        public void addAtomic() {
        
            atomicInteger.getAndIncrement();
        }
    
    }

*  程序运行结果

原子性测试
    main	 int type finally number value: 17591
    main	 AtomicInteger type finally number value: 20000

> **瞅瞅 AtomicInteger 源码**

**先获取再修改**

*  getAndIncrement() 方法

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

*  getAndDecrement() 方法

public final int getAndDecrement() {
        
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

*  getAndAdd() 方法

public final int getAndAdd(int delta) {
        
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

*  总结：以上方法都通过调用 unsafe.getAndAddInt() 实现

--------------------

**先修改再获取**

*  incrementAndGet() 方法

public final int incrementAndGet() {
        
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

*  decrementAndGet() 方法

public final int decrementAndGet() {
        
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }

*  addAndGet() 方法

public final int addAndGet(int delta) {
        
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

*  总结：以上方法都通过调用 unsafe.getAndAddInt() + delta 实现

#### 1.2.4、代码重排 ####

> **有序性**

计算机在执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排，一般分以下3种

![image-20200807143528418][]

--------------------

**理解指令重排序**

1.  指令重排序，就是出于优化考虑，CPU执行指令的顺序跟程序员自己编写的顺序不一致
2.  就好比一份试卷，题号是老师规定的，是程序员规定的，但是考生（CPU）可以先做选择，也可以先做填空

--------------------

1.  单线程环境里面可以确保程序最终执行结果和代码顺序执行的结果一致
2.  处理器在进行重排序时必须要考虑**指令之间的数据依赖性**
3.  多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测

> **重排代码示例**

**示例 1**

*  代码

public void mySort(){
        
        int x = 11; //语句1
        int y = 12; //语句2
        x = x + 5;  //语句3
        y = x * x;  //语句4
    }

*  以上代码，可能出现的执行顺序有1234、2134、1342，这三个都没有问题，但是语句 4 不能变成第一条，因为存在数据依赖（y 依赖于 x）。

--------------------

**示例 2**

1.  在代码中定义了 a, b, x, y 四个整形变量
2.  线程 1 原本的执行顺序为 `x = a; b = 1;` ，线程 2 原本的执行顺序为 `y = b; a = 1;`
3.  但是经过指令重排后，指令执行顺序变化，导致程序执行结果变化
4.  这也就说明在多线程环境下，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的。

![image-20200807145328566][]

--------------------

**示例 3**

*  代码

![image-20200807150125103][]

分析：

1.  变量 a 与 flag 并没有数据依赖性，所以 a = 1; 与 flag = true; 语句无法保证谁先谁后
2.  线程操作资源类，线程1访问method1，线程2访问method2，正常情况顺序执行，a=6
3.  多线程下假设出现了指令重排，语句2在语句1之前，当执行完flag=true后，另一个线程马上执行method2，则会输出 a=5

> **禁止指令重排案例小结**

1.  volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象
2.  我们先了解一个概念，**内存屏障（Memory Barrfer）又称内存栅栏**，是一个CPU指令，它的作用有两个：
    
     *  一是**保证特定操作的执行顺序**
     *  二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。
3.  由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通**过插入内存屏障禁止在内存屏障前后的指令执行重排序优化**。
4.  内存屏障另外一个作用是**强制刷出各种CPU的缓存数据**，因此任何CPU上的线程都能读取到这些数据的最新版本。

![image-20200807151131161][]

### 1.3、线程安全性保证 ###

> **如何使线程安全性获得保证**

1.  **工作内存与主内存同步延迟现象导致的可见性问题可以使用synchronized或volatile关键字解决**，它们都可以使一个线程修改后的变量立即对其他线程可见。
2.  **对于指令重排导致的可见性问题和有序性问题可以利用volatile关键字解决**，因为volatile的另外一个作用就是禁止重排序优化。

### 1.4、volatile 单例模式 ###

#### 1.4.1、DCL 单例模式 ####

> **DCL模式：Double Check Lock，即双端检索机制：在加锁前后都进行判断**

*  代码

/**
     * @ClassName SingletonDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 15:14
     * @Version 1.0
     */
    public class SingletonDemo {
        
    
        private static SingletonDemo singletonDemo = null;
    
        private SingletonDemo() {
        
            System.out.println(Thread.currentThread().getName() + "\t 我是构造方法");
        }
    
        //DCL模式 Double Check Lock 双端检索机制：在加锁前后都进行判断
        public static SingletonDemo getInstance() {
        
            if (singletonDemo == null) {
        
                synchronized (SingletonDemo.class) {
        
                    if (singletonDemo == null) {
        
                        singletonDemo = new SingletonDemo();
                    }
                }
            }
            return singletonDemo;
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 10000; i++) {
        
                new Thread(() -> {
        
                    SingletonDemo.getInstance();
                }, String.valueOf(i + 1)).start();
            }
        }
    
    }

*  这种写法在多线程条件下可能正确率为 99.999999%，但可能由于指令重排出错

#### 1.4.2、单例volatile 分析 ####

> **DCL 问题分析：**

1.  DCL（双端检锁）机制不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排
2.  原因：可能出现某一个线程执行到第一次检测，读取到的instance不为null时，但是instance的引用对象可能没有完成初始化。原因如下：
3.  实例化代码 `instance=new SingletonDemo();` 可以分为以下3步完成（伪代码）
    
        memory=allocate(); 	//1.分配对象内存空间
        instance(memory)	//2.初始化对象
        instance=memory;	//3.设置instance指向刚分配的内存地址，此时instance!=null
4.  **步骤2和步骤3不存在数据依赖关系**，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。
    
        memory=allocate();	//1.分配对象内存空间
        instance=memory;	//3.设置instance指向刚分配的内存地址，此时instance!=null，但是对象还没有初始化完成！
        instance(memory);	//2.初始化对象
5.  指令重排只会保证串行语义的执行的一致性（单线程），但并不会关心多线程间的语义一致性。**所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成**，也就造成了线程安全问题。
6.  就比如说我们需要使用 instance 对象中的一个对象 heygo ，但是由于 instance 并未初始化完成，此时 heygo == null ，访问 instance.heygo 将抛出空指针异常

> **单例模式正确写法：**

加上 volatile ，禁止指令重排

private static volatile SingletonDemo singletonDemo=null;

## 2、CAS 算法 ##

> **CAS你知道吗？**

### 2.1、CAS 概述 ###

> **CAS：compare and set（比较并交换）**

**代码示例**

*  代码

/**
     * @ClassName CASDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 15:43
     * @Version 1.0
     */
    public class CASDemo {
        
        public static void main(String[] args) {
        
            /*
             CAS是什么？ ==>compareAndSet 比较并交换
            */
            AtomicInteger atomicInteger = new AtomicInteger(5);
            // 期望值与上次相同，修改成功
            System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t current data : " + atomicInteger.get());
            // 期望值与上次不同，修改失败
            System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t current data : " + atomicInteger.get());
        }
    }

*  程序运行结果

true	 current data : 2019
    false	 current data : 2019

分析CAS：就拿 JMM 模型来说

1.  现在有两个线程：线程 A 和线程 B ，同时操作主内存中的变量 i
2.  线程 A 将变量 i 的副本拷贝回自己线程的工作内存，先记录变量 i 当前的值，记录为期望值
3.  线程 A 修改值后，将 i 的值写回主内存前，**先判断一下当前主内存的值是否与期望值相等，相等我才写回，不相等证明别的线程（线程 B）改过了**，如果强行写，将出现写覆盖

### 2.2、CAS 原理 ###

#### 2.2.1、Unsafe 类 ####

> **CAS底层原理？如果知道，谈谈你对Unsafe的理解**

一句话总结：**自旋锁 + Unsafe 类**

> **AtomicInteger 类的底层源码**

*  getAndIncrement() 方法

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

*  分析参数含义

1.  this：当前对象
2.  valueOffset：**内存偏移量**（内存地址）
3.  为什么AtomicInteger能解决i++多线程下不安全的问题，靠的是底层的**Unsafe类**

--------------------

*  AtomicInteger 类中维护了一个 Unsafe 实例，和一个 volatile 修饰的 value 值

public class AtomicInteger extends Number implements java.io.Serializable {
        
        private static final long serialVersionUID = 6214790243416807050L;
    
        // setup to use Unsafe.compareAndSwapInt for updates
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static {
        
            try {
        
                valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
            } catch (Exception ex) {
         throw new Error(ex); }
        }
    
        private volatile int value;

> **Unsafe 类**

1.  Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，**Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据**。
2.  Unsafe类存在于sun.misc包中，**其内部方法操作可以像C的指针一样直接操作内存**，Java中CAS操作的执行依赖于Unsafe类的方法。
3.  注意Unsafe类中的所有方法都是native修饰的，也就是说**Unsafe类中的方法都直接调用操作系统底层资源执行相应在务**。
4.  **变量valueOffset，表示该量值在内存中的偏移地址**，因为Unsafe就是根据内存偏移地址获取数据的。
5.  变量value用volatile修饰，保证了**多线程之间的内存可见性**。

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

#### 2.2.2、CAS 是什么 ####

> **CAS 到底是个什么玩意儿？**

1.  CAS的全称为Compare-And-Swap，**它是一条CPU并发原语**。
2.  它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是**原子**的。
3.  CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，**JVM会帮我们实现出CAS汇编指令**。这是一种**完全依赖于硬件的功能**，通过它实现了原子操作。
4.  再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且**原语的执行必须是连续的，在执行过程中不允许被中断**，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

> **AtomicInteger 类 CAS 算法分析**

*  通过 AtomicInteger 类调用 getAndIncrement() 方法

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

*  `atomicInteger.getAndIncrement()` 方法调用 `unsafe.getAndAddInt()` 方法
    
     *  `this.getIntVolatile(var1,var2)` 方法获取var1这个对象在var2地址上的值
     *  `this.compareAndSwapInt(var1, var2, var5, var5 + var4)` 方法判断 var5 变量是否与期望值相同：
        
         *  如果 var5 与内存中的期望值相同，证明没有其他线程改过，则执行 +var 操作
         *  如果 var5 与内存中的期望值不同，证明没有其他线程改过 var2 地址处的值，然后再重新获取 var2 地址处的值，重复 compare and set 操作

public final int getAndAddInt(Object var1, long var2, int var4) {
        
        int var5;
        do {
        
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
        return var5;
    }

*  总结：getAndIncrement()方法底层调用的是Unsafe类的getAndAddInt()方法，底层是CAS思想

> **atomicInteger.getAndIncrement() 方法详解**

*  AtomicInteger 类的 getAndIncrement() 方法

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

*  Unsafe 类的 getAndAddInt() 方法

**流程分析：**

1.  var1：Atomiclnteger对象本身。
2.  var2：该对象值得引用地址。
3.  var4：需要变动的数量。
4.  var5：使用var1 var2找出的主内存中真实的值。
5.  用该对象当前的值与var5比较：
    
     *  如果相同，更新var5 + var4并且返回true，
     *  如果不同，继续取值然后再比较，直到更新完成。

**举例说明：**

1.  假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑在不同CPU上）：
2.  AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，**根据JMM模型，线程A和线程B各自持有一份值为3的value的副本，分别拷贝到各自的工作内存**。
3.  线程A通过getIntVolatile(var1, var2)拿到value值3，这时线程A被挂起。
4.  线程B也通过getIntVolatile(var1, var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。
5.  这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值己经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了。
6.  线程A重新获取value值，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwaplnt进行比较替换，直到成功。

> **底层汇编指令**

1.  Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于unsafe.cpp中
2.  Atomic:cmpxchg 指令：**但凡带 Atomic 汇编指令都是不会被其他线程打断**

![image-20200807170454109][]

> **CAS 简单小总结**

**CAS（CompareAndSwap）**

比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较直到主内存和工作内存中的值一致为止

--------------------

**CAS应用**

1.  CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。
2.  当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

### 2.3、CAS 缺点 ###

> **1、循环时间长开销很大**

我们可以看到getAndAddInt方法执行时，有个do while

如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

> **2、只能保证一个共享变量的原子操作**

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

> **3、引出来ABA问题？**

### 2.4、面试题 ###

> **为什么用 CAS 而不用synchronized？**

以下是我的理解

1.  使用 synchronized 虽然能保证操作的原子性，但是将操作变成了**串行操作**，大大降低了程序的并发性
2.  如果使用 synchronized 没有抢到同步锁，那么线程将处于阻塞状态，等待 CPU 的下一次调度
3.  CAS 使用 Unsafe 类 + 自旋锁实现操作的原子性，Unsafe 类中使用 do while 循环实现 compare and set ，多个线程可以同时操作，大大提高了程序的并发性，并且不存在让线程等待的问题

## 3、ABA 问题 ##

> **原子类AtomicInteger的ABA问题？原子更新引用知道吗？**

### 3.1、ABA 问题的产生 ###

> **面试坑爹套路**

CAS —> UnSafe —> CAS底层思想 —> ABA —> 原子引用更新 —> 如何规避ABA问题

> **ABA问题是怎样产生的？**

**CAS会导致 ABA 问题**

1.  CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。
2.  比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。
3.  尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。
4.  一句话总结：**狸猫换太子**

### 3.2、原子引用 ###

> **原子引用代码示例**

*  代码：使用 AtomicReference 原子引用类封装我们自定义的 User 类

/**
     * @ClassName AtomicReferenceDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 18:45
     * @Version 1.0
     */
    public class AtomicReferenceDemo {
        
    
        public static void main(String[] args) {
        
            AtomicReference<User> atomicReference = new AtomicReference<>();
    
            User z3 = new User("z3", 23);
            User l4 = new User("l4", 24);
            User w5 = new User("w5", 25);
    
    
            atomicReference.set(z3);
            System.out.println(atomicReference.compareAndSet(z3, l4) + "\t" + atomicReference.get().toString());
            System.out.println(atomicReference.compareAndSet(z3, w5) + "\t" + atomicReference.get().toString());
        }
    
    }
    
    class User {
        
    
        String userName;
        int age;
    
        public User(String userName, int age) {
        
            this.userName = userName;
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

*  程序运行结果

true	User{userName='l4', age=24}
    false	User{userName='l4', age=24}

### 3.3、版本号原子引用 ###

> **解决ABA问题：理解原子引用 + 新增一种机制，那就是修改版本号（类似时间戳）**

*  代码：使用带版本号的原子类 AtomicStampedReference 解决 ABA 问题

/**
     * @ClassName ABADemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 21:08
     * @Version 1.0
     */
    public class ABADemo {
        
        // 初始值为 100
        static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
        // 初始值为 100 ，初始版本号为 1
        static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
    
    
        public static void main(String[] args) {
        
    
            System.out.println("======ABA问题的产生======");
            new Thread(() -> {
        
                atomicReference.compareAndSet(100, 101);
                atomicReference.compareAndSet(101, 100);
            }, "t1").start();
    
            new Thread(() -> {
        
                // 暂停1秒钟线程2，保证上面t1线程完成一次ABA操作
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get());
            }, "t2").start();
    
            // 保证上面的操作执行完成
            while (Thread.activeCount() > 2) {
        
                Thread.yield();
            }
    
            System.out.println("======以下是ABA问题的解决=====");
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + atomicStampedReference.getStamp());
                // 暂停1秒钟t3线程
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + "\t第2次版本号：" + atomicStampedReference.getStamp());
                atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + "\t第3次版本号：" + atomicStampedReference.getStamp());
            }, "t3").start();
    
            new Thread(() -> {
        
                int stamp = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
                // 暂停3秒钟t4线程，保证上面t3线程完成一次ABA操作
                try {
        
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, atomicStampedReference.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + "\t修改成功否： " + result + "\t当前最新实际版本号：" + atomicStampedReference.getStamp());
                System.out.println(Thread.currentThread().getName() + "\t当前实际值：" + atomicStampedReference.getReference());
            }, "t4").start();
        }
    }

*  程序运行结果

======ABA问题的产生======
    true	2019
    ======以下是ABA问题的解决=====
    t3	第1次版本号：1
    t4	第1次版本号：1
    t3	第2次版本号：2
    t3	第3次版本号：3
    t4	修改成功否： false	当前最新实际版本号：3
    t4	当前实际值：100

> **关于 AtomicStampedReference 的一些说明**

*  AtomicStampedReference 的构造器
    
     *  initialRef：初始值
     *  initialStamp：初始版本号

public AtomicStampedReference(V initialRef, int initialStamp) {
        
        pair = Pair.of(initialRef, initialStamp);
    }

*  compareAndSet() 方法
    
     *  expectedReference：期望值
     *  newReference：新值
     *  expectedStamp：期望版本号
     *  newStamp：新的版本号

public boolean compareAndSet(V   expectedReference,
                                     V   newReference,
                                     int expectedStamp,
                                     int newStamp) {
        
            Pair<V> current = pair;
            return
                expectedReference == current.reference &&
                expectedStamp == current.stamp &&
                ((newReference == current.reference &&
                  newStamp == current.stamp) ||
                 casPair(current, Pair.of(newReference, newStamp)));
        }

## 4、集合框架 ##

> **我们知道ArrayList是线程不安全，请编码一个不安全的案例并给出解决方案**

### 4.1、ArrayList 不安全 ###

> **我们知道ArrayList是线程不安全，请编码一个不安全的案例并给出解决方案**

*  代码

*  程序运行结果：由于 ArrayList 类的 add() 方法没有加锁，所以存在多线程并发安全问题

java.util.ConcurrentModificationException
    	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    	at java.util.ArrayList$Itr.next(ArrayList.java:851)
    	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
    	at java.lang.String.valueOf(String.java:2994)
    	at java.lang.StringBuilder.append(StringBuilder.java:131)
    	at com.Heygo.ContainerNotSafeDemo.lambda$listNotSafe$0(ContainerNotSafeDemo.java:26)
    	at java.lang.Thread.run(Thread.java:748)

> **解决问题 ArrayList 线程不安全**

1.  使用 `new Vector<>();`（ArrayList所有方法加synchronized，太重）。
2.  使用 `Collections.synchronizedList(new ArrayList<>());` 转换成线程安全类。
3.  使用 `new java.concurrent.CopyOnWriteArrayList<>();`（推荐）。

> **CopyOnWriteArrayList**

**CopyOnWriteArrayList 写时复制**

1.  写时复制：CopyOnWrite容器，即写时复制的容器。
2.  往一个容器添加元素的时候，不直接往当前容器 Object\[\] 添加，而是先将当前 Object\[\] 进行Copy，复制出一个新的容器Object\[\] newElements，然后新的容器Object\[\] newElements里添加元素，添加完元素之后，再将原容器的引用指向新的容器setArray(newElements)
3.  这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。
4.  所以CopyOnWrite容器也是一种**读写分离**的思想，读和写不同的容器。

--------------------

**CopyOnWriteArrayList 代码示例**

*  代码：使用 CopyOnWriteArrayList 集合类，保证 ArrayList 并发修改安全性的同时，也保证了并发读取的效率

/**
     * @ClassName ContainerNotSafeDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 21:35
     * @Version 1.0
     */
    public class ContainerNotSafeDemo {
        
    
        /*
         * 1 故障现象
         *   java.util.ConcurrentModificationException
         *
         * 2 导致原因
         *   并发争抢修改导致，参考我们的花名册签名情况。
         *   一个人正在写入，另一个同学过来抢夺，导致数据不一致异常。并发修改异常。
         *
         * 3 解决方案
         *   3.1 new Vector<>();
         *   3.2 集合工具类：Collections.synchronizedList(new ArrayList<>());
         *   3.3 new CopyOnWriteArrayList<>()
         *       写时复制：CopyOnWrite容器即写时复制的容器。
         *       往一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前object[]进行Copy，
         *       复制出一个新的容器Object[] newElements，然后新的容器Object[] newElements里添加元素，
         *       添加完元素之后，再将原容器的引用指向新的容器setArray(newElements);
         *       这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。
         *       所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
         *
         * 4 优化建议（同样的错误不犯两次）
         *
         * */
        public static void main(String[] args) {
        
            listNotSafe();
        }
    
        private static void listNotSafe() {
        
            List<String> list = new CopyOnWriteArrayList<>();
            for (int i = 1; i <= 30; i++) {
        
                new Thread(() -> {
        
                    list.add(UUID.randomUUID().toString().substring(0, 8));
                    System.out.println(Thread.currentThread().getName() + "\t" + list);
                }, String.valueOf(i)).start();
            }
        }
    
    }

*  程序运行结果

5	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72]
    8	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9]
    10	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9]
    2	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9]
    3	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72]
    12	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02]
    7	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e]
    4	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72]
    15	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a]
    14	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e]
    13	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b]
    1	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e]
    22	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a]
    11	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e]
    6	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803]
    9	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64]
    27	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4, 1ce730cc, 5807293f, 8163070f]
    26	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4, 1ce730cc, 5807293f]
    25	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4, 1ce730cc]
    24	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4]
    23	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36]
    21	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d]
    20	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143]
    19	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a]
    18	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e]
    17	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9]
    16	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3]
    30	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4, 1ce730cc, 5807293f, 8163070f, 8bc1cbfc, 58caaadd]
    29	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4, 1ce730cc, 5807293f, 8163070f, 8bc1cbfc, 58caaadd, ce11ccb2]
    28	[ce629c0f, 195253cd, 9d98dc22, b3ed3b72, 1542d43e, 1494f2e9, aa7e9f64, 413cf9d9, ce7e5748, 1feaa74e, 6d40a803, 5fa45f02, 86971d8b, 14886d8e, 232c6e3a, ecf34ff3, 9aa964b9, a4cf1f6e, 5427a83a, 250c0143, 4c32f82d, a76fe96a, e28f0c36, ee151ef4, 1ce730cc, 5807293f, 8163070f, 8bc1cbfc]

> **ArrayList 源码分析**

*  初始化时，构造了一个**空的 `Object[]` 数组**

/**
         * Shared empty array instance used for default sized empty instances. We
         * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
         * first element is added.
         */
        private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
        };
    
    	/**
         * Constructs an empty list with an initial capacity of ten.
         */
        public ArrayList() {
        
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }

*  ArrayList 中**使用 `Object[]` 数组存放数据**

/**
         * The array buffer into which the elements of the ArrayList are stored.
         * The capacity of the ArrayList is the length of this array buffer. Any
         * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
         * will be expanded to DEFAULT_CAPACITY when the first element is added.
         */
        transient Object[] elementData; // non-private to simplify nested class access

*  第一次添加元素时，初始化 Object\[\] 数组的大小为 `DEFAULT_CAPACITY = 10`

/**
         * Appends the specified element to the end of this list.
         *
         * @param e element to be appended to this list
         * @return <tt>true</tt> (as specified by {@link Collection#add})
         */
        public boolean add(E e) {
        
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
        /**
         * Default initial capacity.
         */
        private static final int DEFAULT_CAPACITY = 10;
    
        private void ensureCapacityInternal(int minCapacity) {
        
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
    
            ensureExplicitCapacity(minCapacity);
        }

*  扩容操作
    
     *  每次扩容为旧容量的 1.5 倍
     *  ArrayList 最大容量为 `Integer.MAX_VALUE - 8`
     *  使用 `Arrays.copyOf()`方法扩容，并将将原来数组中的值拷贝到新数组中

private void ensureExplicitCapacity(int minCapacity) {
        
            modCount++;
    
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
    
        /**
         * The maximum size of array to allocate.
         * Some VMs reserve some header words in an array.
         * Attempts to allocate larger arrays may result in
         * OutOfMemoryError: Requested array size exceeds VM limit
         */
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
        /**
         * Increases the capacity to ensure that it can hold at least the
         * number of elements specified by the minimum capacity argument.
         *
         * @param minCapacity the desired minimum capacity
         */
        private void grow(int minCapacity) {
        
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

> **Collections. synchronizedList() 源码**

*  `Collections.synchronizedList()` 方法：由于 ArrayList 实现了 RandomAccess 接口，所以在方法内部创建了一个 SynchronizedRandomAccessList 的实例

/**
         * Returns a synchronized (thread-safe) list backed by the specified
         * list.  In order to guarantee serial access, it is critical that
         * <strong>all</strong> access to the backing list is accomplished
         * through the returned list.<p>
         *
         * It is imperative that the user manually synchronize on the returned
         * list when iterating over it:
         * <pre>
         *  List list = Collections.synchronizedList(new ArrayList());
         *      ...
         *  synchronized (list) {
         *      Iterator i = list.iterator(); // Must be in synchronized block
         *      while (i.hasNext())
         *          foo(i.next());
         *  }
         * </pre>
         * Failure to follow this advice may result in non-deterministic behavior.
         *
         * <p>The returned list will be serializable if the specified list is
         * serializable.
         *
         * @param  <T> the class of the objects in the list
         * @param  list the list to be "wrapped" in a synchronized list.
         * @return a synchronized view of the specified list.
         */
        public static <T> List<T> synchronizedList(List<T> list) {
        
            return (list instanceof RandomAccess ?
                    new SynchronizedRandomAccessList<>(list) :
                    new SynchronizedList<>(list));
        }

*  SynchronizedRandomAccessList 类是 Collections 类的静态内部类
 *  SynchronizedRandomAccessList 的父类为 SynchronizedList 类
 *  `super(list);` 表示调用父类 SynchronizedList 的构造方法

static class SynchronizedRandomAccessList<E>
        extends SynchronizedList<E>
        implements RandomAccess {
        
    
        SynchronizedRandomAccessList(List<E> list) {
        
            super(list);
        }

*  SynchronizedList 类也是 Collections 类的静态内部类
 *  SynchronizedList 类的父类是 SynchronizedCollection 类
 *  `super(list);` 表示调用父类 SynchronizedCollection 的构造方法
 *  SynchronizedList 内部维护了 ArrayList 的引用：`this.list = list;`

static class SynchronizedList<E>
        extends SynchronizedCollection<E>
        implements List<E> {
        
        private static final long serialVersionUID = -7754090372962971524L;
    
        final List<E> list;
    
        SynchronizedList(List<E> list) {
        
            super(list);
            this.list = list;
        }

*  SynchronizedCollection 类也是 Collections 类的静态内部类
 *  在 SynchronizedCollection 内部维护了 ArrayList 的引用：`this.c = Objects.requireNonNull(c);`
 *  通过 `final Object mutex` 这把锁，给集合中的所有方法都加上锁，保证多线程并发的安全性

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
        
        private static final long serialVersionUID = 3053995032091335093L;
    
        final Collection<E> c;  // Backing Collection
        final Object mutex;     // Object on which to synchronize
    
        SynchronizedCollection(Collection<E> c) {
        
            this.c = Objects.requireNonNull(c);
            mutex = this;
        }
    
        SynchronizedCollection(Collection<E> c, Object mutex) {
        
            this.c = Objects.requireNonNull(c);
            this.mutex = Objects.requireNonNull(mutex);
        }
    
        public int size() {
        
            synchronized (mutex) {
        return c.size();}
        }
        public boolean isEmpty() {
        
            synchronized (mutex) {
        return c.isEmpty();}
        }
        public boolean contains(Object o) {
        
            synchronized (mutex) {
        return c.contains(o);}
        }
        public Object[] toArray() {
        
            synchronized (mutex) {
        return c.toArray();}
        }
        public <T> T[] toArray(T[] a) {
        
            synchronized (mutex) {
        return c.toArray(a);}
        }
    
        public Iterator<E> iterator() {
        
            return c.iterator(); // Must be manually synched by user!
        }
    
        public boolean add(E e) {
        
            synchronized (mutex) {
        return c.add(e);}
        }
        public boolean remove(Object o) {
        
            synchronized (mutex) {
        return c.remove(o);}
        }
    
        public boolean containsAll(Collection<?> coll) {
        
            synchronized (mutex) {
        return c.containsAll(coll);}
        }
        public boolean addAll(Collection<? extends E> coll) {
        
            synchronized (mutex) {
        return c.addAll(coll);}
        }
        public boolean removeAll(Collection<?> coll) {
        
            synchronized (mutex) {
        return c.removeAll(coll);}
        }
        public boolean retainAll(Collection<?> coll) {
        
            synchronized (mutex) {
        return c.retainAll(coll);}
        }
        public void clear() {
        
            synchronized (mutex) {
        c.clear();}
        }
        public String toString() {
        
            synchronized (mutex) {
        return c.toString();}
        }
        // Override default methods in Collection
        @Override
        public void forEach(Consumer<? super E> consumer) {
        
            synchronized (mutex) {
        c.forEach(consumer);}
        }
        @Override
        public boolean removeIf(Predicate<? super E> filter) {
        
            synchronized (mutex) {
        return c.removeIf(filter);}
        }
        @Override
        public Spliterator<E> spliterator() {
        
            return c.spliterator(); // Must be manually synched by user!
        }
        @Override
        public Stream<E> stream() {
        
            return c.stream(); // Must be manually synched by user!
        }
        @Override
        public Stream<E> parallelStream() {
        
            return c.parallelStream(); // Must be manually synched by user!
        }
        private void writeObject(ObjectOutputStream s) throws IOException {
        
            synchronized (mutex) {
        s.defaultWriteObject();}
        }
    }

> **CopyOnWriteArrayList 源码分析**

*  CopyOnWriteArrayList 内部维护了两个重要成员变量：
    
     *  **ReentrantLock 锁**：保证多线程并发修改的安全性
     *  **Object\[\] array 数组**：使用 volatile 修饰，保证内存的可见性

public class CopyOnWriteArrayList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
        
        private static final long serialVersionUID = 8673264195747942595L;
    
        /** The lock protecting all mutators */
        final transient ReentrantLock lock = new ReentrantLock();
    
        /** The array, accessed only via getArray/setArray. */
        private transient volatile Object[] array;
    
        /**
         * Gets the array.  Non-private so as to also be accessible
         * from CopyOnWriteArraySet class.
         */
        final Object[] getArray() {
        
            return array;
        }
    
        /**
         * Sets the array.
         */
        final void setArray(Object[] a) {
        
            array = a;
        }
    
        /**
         * Creates an empty list.
         */
        public CopyOnWriteArrayList() {
        
            setArray(new Object[0]);
        }

*  添加元素：
    
     *  上锁\{
     *  **数组长度扩容 1 个元素**，将旧元素拷贝至新数组与中，**将新元素放在数组末尾**
     *  修改 `rivate transient volatile Object[] array;` 的引用
     *  \}解锁

/**
         * Appends the specified element to the end of this list.
         *
         * @param e element to be appended to this list
         * @return {@code true} (as specified by {@link Collection#add})
         */
        public boolean add(E e) {
        
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
        
                Object[] elements = getArray();
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len + 1);
                newElements[len] = e;
                setArray(newElements);
                return true;
            } finally {
        
                lock.unlock();
            }
        }

*  由于采用了读写分离，所以读取集合无需加锁，提高了读的并发性

public String toString() {
        
        return Arrays.toString(getArray());
    }

### 4.2、HashSet 不安全 ###

> **演示 HashSet 线程不安全**

*  代码

/**
     * @ClassName ContainerNotSafeDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 21:35
     * @Version 1.0
     */
    public class ContainerNotSafeDemo {
        
        public static void main(String[] args) {
        
            setNoSafe();
        }
    
        private static void setNoSafe() {
        
            Set<String> set=new HashSet<>();
            for (int i = 1; i <= 30; i++) {
        
                new Thread(() -> {
        
                    set.add(UUID.randomUUID().toString().substring(0, 8));
                    System.out.println(Thread.currentThread().getName() + "\t" + set);
                }, String.valueOf(i)).start();
            }
        }
    }

*  程序运行结果：`java.util.ConcurrentModificationException`

java.util.ConcurrentModificationException
    	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437)
    	at java.util.HashMap$KeyIterator.next(HashMap.java:1461)
    	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
    	at java.lang.String.valueOf(String.java:2994)
    	at java.lang.StringBuilder.append(StringBuilder.java:131)
    	at com.Heygo.ContainerNotSafeDemo.lambda$setNoSafe$2(ContainerNotSafeDemo.java:71)
    	at java.lang.Thread.run(Thread.java:748)

> **解决 HashSet 线程不安全问题**

1.  使用 CollectionssynchronizedSet() 方法将 HashSet 转为线程安全版本
2.  使用 CopyOnWriteArraySet 类：读写分离

--------------------

**CopyOnWriteArraySet 代码示例**

*  代码

/**
     * @ClassName ContainerNotSafeDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 21:35
     * @Version 1.0
     */
    public class ContainerNotSafeDemo {
        
        public static void main(String[] args) {
        
            setNoSafe();
        }
    
        private static void setNoSafe() {
        
            Set<String> set = new CopyOnWriteArraySet<>();
            for (int i = 1; i <= 30; i++) {
        
                new Thread(() -> {
        
                    set.add(UUID.randomUUID().toString().substring(0, 8));
                    System.out.println(Thread.currentThread().getName() + "\t" + set);
                }, String.valueOf(i)).start();
            }
        }
    }

*  程序运行结果

1	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb]
    7	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a]
    16	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177]
    18	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e]
    15	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a]
    21	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e]
    4	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7]
    3	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7]
    2	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7]
    13	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7]
    24	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d]
    8	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9]
    14	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9]
    30	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d, 85e01c3e, 0edf78f9, a0c65913]
    5	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d]
    11	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d]
    9	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb]
    12	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24]
    26	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d, 85e01c3e, 0edf78f9, a0c65913, 9ae99682, 84b58b16]
    25	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d, 85e01c3e, 0edf78f9, a0c65913, 9ae99682]
    29	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d, 85e01c3e, 0edf78f9, a0c65913, 9ae99682]
    28	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d, 85e01c3e, 0edf78f9]
    27	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698, 22177284, 6252e23d, 85e01c3e]
    22	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22, 866bc698]
    23	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7, 3f6ded3e, f995ef22]
    20	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89, 73bd78e7]
    19	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6, 23fbb23e, ec60cb89]
    17	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a, 25b9d177, e5567ae6]
    6	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb]
    10	[d9f8ebbc, 1d6205eb, 836575a9, ce40bd87, 7bacd0f6, 57d5347f, e1676b1c, c10c5256, 247ff963, 3a5b3feb, ce846b2d, 9e050a24, 0e7e56e9, bf76ebc7, 6072428a]

> **HashSet 源码分析**

*  HashSet 的构造器：底层维护了一个**负载因子为 0.75 的 HashMap**

public class HashSet<E>
        extends AbstractSet<E>
        implements Set<E>, Cloneable, java.io.Serializable
    {
        
        static final long serialVersionUID = -5024744406713321676L;
    
        private transient HashMap<E,Object> map;
    
        // Dummy value to associate with an Object in the backing Map
        private static final Object PRESENT = new Object();
    
        /**
         * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
         * default initial capacity (16) and load factor (0.75).
         */
        public HashSet() {
        
            map = new HashMap<>();
        }

*  add() 方法：
    
     *  key 为待添加的元素
     *  value 统一为 `private static final Object PRESENT = new Object();`

/**
         * Adds the specified element to this set if it is not already present.
         * More formally, adds the specified element <tt>e</tt> to this set if
         * this set contains no element <tt>e2</tt> such that
         * <tt>(e==null ? e2==null : e.equals(e2))</tt>.
         * If this set already contains the element, the call leaves the set
         * unchanged and returns <tt>false</tt>.
         *
         * @param e element to be added to this set
         * @return <tt>true</tt> if this set did not already contain the specified
         * element
         */
        public boolean add(E e) {
        
            return map.put(e, PRESENT)==null;
        }

> **Collections.synchronizedSet() 源码分析**

*  `Collections.synchronizedSet()` 方法创建了一个 synchronizedSet 类的实例

/**
         * Returns a synchronized (thread-safe) set backed by the specified
         * set.  In order to guarantee serial access, it is critical that
         * <strong>all</strong> access to the backing set is accomplished
         * through the returned set.<p>
         *
         * It is imperative that the user manually synchronize on the returned
         * set when iterating over it:
         * <pre>
         *  Set s = Collections.synchronizedSet(new HashSet());
         *      ...
         *  synchronized (s) {
         *      Iterator i = s.iterator(); // Must be in the synchronized block
         *      while (i.hasNext())
         *          foo(i.next());
         *  }
         * </pre>
         * Failure to follow this advice may result in non-deterministic behavior.
         *
         * <p>The returned set will be serializable if the specified set is
         * serializable.
         *
         * @param  <T> the class of the objects in the set
         * @param  s the set to be "wrapped" in a synchronized set.
         * @return a synchronized view of the specified set.
         */
        public static <T> Set<T> synchronizedSet(Set<T> s) {
        
            return new SynchronizedSet<>(s);
        }

*  SynchronizedSet 类是 Collections 的静态内部类
 *  SynchronizedSet 类的父类是 SynchronizedCollection 类
 *  `super(s);` 调用父类构造器

static class SynchronizedSet<E>
        extends SynchronizedCollection<E>
        implements Set<E> {
        
        private static final long serialVersionUID = 487447009682186044L;
    
        SynchronizedSet(Set<E> s) {
        
            super(s);
        }

*  SynchronizedSet 和 SynchronizedList 都继承自 SynchronizedCollection 类，均是通过 mutex 这把锁解决了多线程并发修改的安全问题

> **CopyOnWriteArraySet 源码分析**

*  CopyOnWriteArraySet 内部维护了一个 CopyOnWriteArrayList 实例，典型的**挂羊皮卖狗肉**

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
            implements java.io.Serializable {
        
        private static final long serialVersionUID = 5457747651344034263L;
    
        private final CopyOnWriteArrayList<E> al;
    
        /**
         * Creates an empty set.
         */
        public CopyOnWriteArraySet() {
        
            al = new CopyOnWriteArrayList<E>();
        }

*  `copyOnWriteArraySet.add()` 方法：调用 `copyOnWriteArrayList.addIfAbsent()` 方法

// CopyOnWriteArraySet 类的 add() 方法
    	/**
         * Adds the specified element to this set if it is not already present.
         * More formally, adds the specified element {@code e} to this set if
         * the set contains no element {@code e2} such that
         * <tt>(e==null ? e2==null : e.equals(e2))</tt>.
         * If this set already contains the element, the call leaves the set
         * unchanged and returns {@code false}.
         *
         * @param e element to be added to this set
         * @return {@code true} if this set did not already contain the specified
         *         element
         */
        public boolean add(E e) {
        
            return al.addIfAbsent(e);
        }

*  `copyOnWriteArrayList.addIfAbsent()` 方法：
    
     *  获取 Object\[\] 数组的快照
     *  将元素添加至 ArrayList（这里看不太懂）

/**
         * Appends the element, if not present.
         *
         * @param e element to be added to this list, if absent
         * @return {@code true} if the element was added
         */
        public boolean addIfAbsent(E e) {
        
            Object[] snapshot = getArray();
            return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
                addIfAbsent(e, snapshot);
        }
    
        /**
         * A version of addIfAbsent using the strong hint that given
         * recent snapshot does not contain e.
         */
        private boolean addIfAbsent(E e, Object[] snapshot) {
        
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
        
                Object[] current = getArray();
                int len = current.length;
                if (snapshot != current) {
        
                    // Optimize for lost race to another addXXX operation
                    int common = Math.min(snapshot.length, len);
                    for (int i = 0; i < common; i++)
                        if (current[i] != snapshot[i] && eq(e, current[i]))
                            return false;
                    if (indexOf(e, current, common, len) >= 0)
                            return false;
                }
                Object[] newElements = Arrays.copyOf(current, len + 1);
                newElements[len] = e;
                setArray(newElements);
                return true;
            } finally {
        
                lock.unlock();
            }
        }

### 4.3、HashMap 线程不安全 ###

> **演示 HashMap 线程不安全**

*  代码

/**
     * @ClassName ContainerNotSafeDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 21:35
     * @Version 1.0
     */
    public class ContainerNotSafeDemo {
        
        public static void main(String[] args) {
        
            mapNotSafe();
        }
    
        private static void mapNotSafe() {
        
            Map<String,String> map=new HashMap<>();
            for (int i = 1; i <= 30; i++) {
        
                new Thread(() -> {
        
                    map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                    System.out.println(Thread.currentThread().getName() + "\t" + map);
                }, String.valueOf(i)).start();
            }
        }
    }

*  程序运行结果：`java.util.ConcurrentModificationException`

java.util.ConcurrentModificationException
    	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437)
    	at java.util.HashMap$EntryIterator.next(HashMap.java:1471)
    	at java.util.HashMap$EntryIterator.next(HashMap.java:1469)
    	at java.util.AbstractMap.toString(AbstractMap.java:554)
    	at java.lang.String.valueOf(String.java:2994)
    	at java.lang.StringBuilder.append(StringBuilder.java:131)
    	at com.Heygo.ContainerNotSafeDemo.lambda$mapNotSafe$1(ContainerNotSafeDemo.java:60)
    	at java.lang.Thread.run(Thread.java:748)

> **解决 HashMap 线程不安全**

*  代码：使用 **ConcurrentHashMap** 类

/**
     * @ClassName ContainerNotSafeDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 21:35
     * @Version 1.0
     */
    public class ContainerNotSafeDemo {
        
        public static void main(String[] args) {
        
            mapNotSafe();
        }
    
        private static void mapNotSafe() {
        
            Map<String,String> map=new ConcurrentHashMap<>();
            for (int i = 1; i <= 30; i++) {
        
                new Thread(() -> {
        
                    map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                    System.out.println(Thread.currentThread().getName() + "\t" + map);
                }, String.valueOf(i)).start();
            }
        }
    }

*  程序运行结果

12	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    16	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    4	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    19	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    6	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 17=7f64e3ee, 6=ad508f93, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    7	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    1	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 17=7f64e3ee, 6=ad508f93, 18=3c3c1d41, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de, 21=f8e65c72}
    22	{11=ae36bafc, 22=3af2e92c, 12=16de3027, 23=e96165a6, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de, 21=f8e65c72}
    25	{22=3af2e92c, 23=e96165a6, 25=71972304, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    2	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    28	{22=3af2e92c, 23=e96165a6, 24=961abac9, 25=71972304, 26=a58c6246, 27=0b742cd8, 28=efe599df, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    3	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    15	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    14	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    30	{22=3af2e92c, 23=e96165a6, 24=961abac9, 25=71972304, 26=a58c6246, 27=0b742cd8, 28=efe599df, 29=ecd71129, 30=7c2cc2a8, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    29	{22=3af2e92c, 23=e96165a6, 24=961abac9, 25=71972304, 26=a58c6246, 27=0b742cd8, 28=efe599df, 29=ecd71129, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    24	{22=3af2e92c, 23=e96165a6, 24=961abac9, 25=71972304, 26=a58c6246, 27=0b742cd8, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    26	{22=3af2e92c, 23=e96165a6, 25=71972304, 26=a58c6246, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    27	{22=3af2e92c, 23=e96165a6, 24=961abac9, 25=71972304, 26=a58c6246, 27=0b742cd8, 10=8f6933de, 11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 21=f8e65c72}
    23	{11=ae36bafc, 12=16de3027, 23=e96165a6, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de, 21=f8e65c72}
    5	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 17=7f64e3ee, 6=ad508f93, 18=3c3c1d41, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de, 21=f8e65c72}
    13	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 17=7f64e3ee, 6=ad508f93, 18=3c3c1d41, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de, 21=f8e65c72}
    21	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de, 21=f8e65c72}
    20	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de}
    10	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 17=7f64e3ee, 6=ad508f93, 18=3c3c1d41, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de}
    18	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 18=3c3c1d41, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 20=6926e455, 10=8f6933de}
    9	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 17=7f64e3ee, 6=ad508f93, 18=3c3c1d41, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    17	{11=ae36bafc, 12=16de3027, 13=dcb688cc, 14=ba2e61d8, 15=f9c89bc1, 16=0c7d1777, 17=7f64e3ee, 19=801d369c, 1=bf7bc1a8, 2=d479c1fe, 3=f036e44c, 4=71eba0d9, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    8	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 19=801d369c, 8=8c1542fa, 9=31d873ac, 10=8f6933de}
    11	{11=ae36bafc, 12=16de3027, 1=bf7bc1a8, 13=dcb688cc, 2=d479c1fe, 14=ba2e61d8, 3=f036e44c, 15=f9c89bc1, 4=71eba0d9, 16=0c7d1777, 5=8d4fab3b, 6=ad508f93, 7=cb593b6f, 8=8c1542fa, 9=31d873ac, 10=8f6933de}

> **HashMap 底层源码**

*  参考资料：https://www.cnblogs.com/iwenwen/p/11052708.html
 *  HashMap 中维护了一个 KV 链表数组：Node<K,V>\[\]

transient Node<K,V>[] table;

--------------------

**构造方法**

*  默认构造函数：负载因子为 0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
    	/**
         * Constructs an empty <tt>HashMap</tt> with the default initial capacity
         * (16) and the default load factor (0.75).
         */
        public HashMap() {
        
            this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
        }

*  通过另一个 Map 创建 HashMap

// 包含另一个“Map”的构造函数
    public HashMap(Map<? extends K, ? extends V> m) {
        
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);//下面会分析到这个方法
    }
    
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        
        int s = m.size();
        if (s > 0) {
        
            // 判断table是否已经初始化
            if (table == null) {
         // pre-size
                // 未初始化，s为m的实际元素个数
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                        (int)ft : MAXIMUM_CAPACITY);
                // 计算得到的t大于阈值，则初始化阈值
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            // 已初始化，并且m元素个数大于阈值，进行扩容处理
            else if (s > threshold)
                resize();
            // 将m中的所有元素添加至HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
        
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

*  指定初始容量大小的构造函数

// 指定“容量大小”的构造函数
    public HashMap(int initialCapacity) {
        
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

*  指定初始容量大小和负载因子的构造函数

// 指定“容量大小”和“加载因子”的构造函数
    public HashMap(int initialCapacity, float loadFactor) {
        
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

--------------------

**添加元素**

*  put() 方法添加元素：
    
     *  如果 tab 数组为空或者长度为 0 ，则扩容
     *  如果定位到的数组位置没有元素 就直接插入
     *  如果定位到的数组位置有元素就和要插入的key比较
        
         *  如果key相同就直接覆盖
         *  如果key不相同，就判断p是否是一个树节点
            
             *  如果是就调用 `e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);` 将元素添加进 HashMap 中
             *  如果不是就遍历链表插入(插入在链表尾部)

public V put(K key, V value) {
        
        return putVal(hash(key), key, value, false, true);
    }
    
    static final int hash(Object key) {
        
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
        
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // table未初始化或者长度为0，进行扩容
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // (n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 桶中已经存在元素
        else {
        
            Node<K,V> e; K k;
            // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                    // 将第一个元素赋值给e，用e来记录
                    e = p;
            // hash值不相等，即key不相等；为红黑树结点
            else if (p instanceof TreeNode)
                // 放入树中
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            // 为链表结点
            else {
        
                // 在链表最末插入结点
                for (int binCount = 0; ; ++binCount) {
        
                    // 到达链表的尾部
                    if ((e = p.next) == null) {
        
                        // 在尾部插入新结点
                        p.next = newNode(hash, key, value, null);
                        // 结点数量达到阈值，转化为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        // 跳出循环
                        break;
                    }
                    // 判断链表中结点的key值与插入的元素的key值是否相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        // 相等，跳出循环
                        break;
                    // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                    p = e;
                }
            }
            // 表示在桶中找到key值、hash值与插入元素相等的结点
            if (e != null) {
         
                // 记录e的value
                V oldValue = e.value;
                // onlyIfAbsent为false或者旧值为null
                if (!onlyIfAbsent || oldValue == null)
                    //用新值替换旧值
                    e.value = value;
                // 访问后回调
                afterNodeAccess(e);
                // 返回旧值
                return oldValue;
            }
        }
        // 结构性修改
        ++modCount;
        // 实际大小大于阈值则扩容
        if (++size > threshold)
            resize();
        // 插入后回调
        afterNodeInsertion(evict);
        return null;
    }

*  put 方法流程图

![image-20200808113755556][]

*  get 方法：如果数组对应位置为 null ，则直接返回 null ，否则去对应链表或者红黑树中去取

public V get(Object key) {
        
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
    
    final Node<K,V> getNode(int hash, Object key) {
        
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        
            // 数组元素相等
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            // 桶中不止一个节点
            if ((e = first.next) != null) {
        
                // 在树中get
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                // 在链表中get
                do {
        
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

*  resize方法：进行扩容，会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是非常耗时的。在编写程序中，**要尽量避免resize**

final Node<K,V>[] resize() {
        
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
        
            // 超过最大值就不再扩充了，就只好随你碰撞去吧
            if (oldCap >= MAXIMUM_CAPACITY) {
        
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 没超过最大值，就扩充为原来的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {
         
            // signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 计算新的resize上限
        if (newThr == 0) {
        
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({
        "rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
        
            // 把每个bucket都移动到新的buckets中
            for (int j = 0; j < oldCap; ++j) {
        
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
        
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else {
         
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
        
                            next = e.next;
                            // 原索引
                            if ((e.hash & oldCap) == 0) {
        
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            // 原索引+oldCap
                            else {
        
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 原索引放到bucket里
                        if (loTail != null) {
        
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 原索引+oldCap放到bucket里
                        if (hiTail != null) {
        
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

> **ConcurrentHashMap 底层源码**

等我功力提升，再回来看

## 5、多线程各种锁 ##

> **公平锁/非公平锁/可重入锁/递归锁/自旋锁，谈谈你的理解？请手写一个自旋锁**

### 5.1、公平锁与非公平锁 ###

> **是个啥玩意儿？**

1.  公平锁：是指多个线程**按照申请锁**的顺序来获取锁，类似排队打饭，先来后到。
2.  非公平锁：是指多个线程获取锁的顺序**并不是按照申请锁的顺序**，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象
3.  并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是**非公平锁**

/**
         * Creates an instance of {@code ReentrantLock}.
         * This is equivalent to using {@code ReentrantLock(false)}.
         */
        public ReentrantLock() {
        
            sync = new NonfairSync();
        }
    
        /**
         * Creates an instance of {@code ReentrantLock} with the
         * given fairness policy.
         *
         * @param fair {@code true} if this lock should use a fair ordering policy
         */
        public ReentrantLock(boolean fair) {
        
            sync = fair ? new FairSync() : new NonfairSync();
        }

> **公平锁与非公平锁的区别**

**公平锁**

1.  公平锁：Threads acquire a fair lock in the order in which they requested it
2.  公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会**按照FIFO的规则**从队列中取到自己

--------------------

**非公平锁**

1.  非公平锁：a nonfair lock permits barging:threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.
2.  非公平锁比较粗鲁，**上来就直接尝试占有锁**，如果尝试失败，就再采用类似公平锁那种方式。

> **题外话**

1.  Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
2.  对于Synchronized而言，也是一种非公平锁

### 5.2、可重入锁 ###

> **可重入锁（又名递归锁）是啥玩意儿？**

1.  可重入锁（也叫做递归锁）指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，**在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁**
2.  就像有了家门的锁，厕所、书房、厨房就为你敞开了一样
3.  也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块
4.  ReentrantLock，synchronized 就是一个典型的可重入锁
5.  可重入锁的最大作用就是避免死锁

> **可重入锁的代码示例**

**synchronized 示例**

*  代码

/**
     * @ClassName RenenterLockDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 13:03
     * @Version 1.0
     */
    
    /*
     * 可重入锁（也就是递归锁）
     *
     * 指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，
     * 在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
     *
     * 也就是说，线程可以进入任何一个它已经拥有的锁所有同步着的代码块。
     *
     * t1   invoked sendSMS()      t1线程在外层方法获取锁的时候
     * t1   invoked sendEmail()    t1在进入内层方法会自动获取锁
     * t2   invoked sendSMS()
     * t2   invoked sendEmail()
     *
     */
    public class RenenterLockDemo {
        
        public static void main(String[] args) {
        
            Phone phone = new Phone();
            new Thread(() -> {
        
                try {
        
                    phone.sendSMS();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }, "t1").start();
    
            new Thread(() -> {
        
                try {
        
                    phone.sendSMS();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }, "t2").start();
        }
    
    }
    
    class Phone {
        
        public synchronized void sendSMS() throws Exception {
        
            System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");
            sendEmail();
        }
    
        public synchronized void sendEmail() throws Exception {
        
            System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
        }
    }

*  程序运行结果

t1	 invoked sendSMS()
    t1	 invoked sendEmail()
    t2	 invoked sendSMS()
    t2	 invoked sendEmail()

--------------------

**ReentrantLock 示例**

*  代码

/**
     * @ClassName RenenterLockDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 13:03
     * @Version 1.0
     */
    
    /*
     * 可重入锁（也就是递归锁）
     *
     * 指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，
     * 在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
     *
     * 也就是说，线程可以进入任何一个它已经拥有的锁所有同步着的代码块。
     *
     */
    public class RenenterLockDemo {
        
        public static void main(String[] args) {
        
            Phone phone = new Phone();
            new Thread(() -> {
        
                try {
        
                    phone.get();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }, "t1").start();
    
            new Thread(() -> {
        
                try {
        
                    phone.get();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }, "t2").start();
        }
    
    }
    
    class Phone implements Runnable {
        
        //Reentrant TEST
        Lock lock = new ReentrantLock();
    
        @Override
        public void run() {
        
            get();
        }
    
        public void get() {
        
            lock.lock();
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t" + "get()");
                set();
            } finally {
        
                lock.unlock();
            }
        }
    
        public void set() {
        
            lock.lock();
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t" + "set()");
            } finally {
        
                lock.unlock();
            }
        }
    }

*  程序运行结果

t1	get()
    t1	set()
    t2	get()
    t2	set()

--------------------

**锁两次，释放两次**

*  代码

class Phone implements Runnable {
        
        //Reentrant TEST
        Lock lock = new ReentrantLock();
    
        @Override
        public void run() {
        
            get();
        }
    
        public void get() {
        
            lock.lock();
            lock.lock();
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t" + "get()");
                set();
            } finally {
        
                lock.unlock();
                lock.unlock();
            }
        }
    
        public void set() {
        
            lock.lock();
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t" + "set()");
            } finally {
        
                lock.unlock();
            }
        }
    }

*  程序运行结果：正常执行

t1	get()
    t1	set()
    t2	get()
    t2	set()

--------------------

**锁两次，释放一次**

*  代码

class Phone implements Runnable {
        
        //Reentrant TEST
        Lock lock = new ReentrantLock();
    
        @Override
        public void run() {
        
            get();
        }
    
        public void get() {
        
            lock.lock();
            lock.lock();
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t" + "get()");
                set();
            } finally {
        
                lock.unlock();
            }
        }
    
        public void set() {
        
            lock.lock();
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t" + "set()");
            } finally {
        
                lock.unlock();
            }
        }
    }

*  程序运行结果：由于 t1 线程未释放 lock 锁，程序卡死（死锁）

![image-20200808132913472][]

--------------------

**结论：锁几次，就释放几次**

### 5.3、自旋锁 ###

> **什么是自旋锁？**

**自旋锁（SpinLock）**

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的**好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU**

> **自旋锁代码示例**

*  代码：使用 AtomicReference 封装 Thread ，通过 CAS算法实现线程的自旋锁

/**
     * 写一个自旋锁
     * 自旋锁的好处：循环比较获取直到成功为止，没有类似wait的阻塞。
     *
     * 通过CAS操作完成自旋锁：
     *  A线程先进来调用myLock方法自已持有锁5秒钟
     *  B随后进来后发现当前有线程持有锁，不是null，
     *  所以只能通过自旋等待，直至A释放锁后B随后抢到
     *
     * @ClassName SpinLockDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 13:37
     * @Version 1.0
     */
    public class SpinLockDemo {
        
        // 泛型为 Thread
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        public void myLock() {
        
            // 获取当前线程
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "\t come in ");
            /*
             自旋：
                期望值为 null 表示当前没有线程
                新值为 thread ，即 Thread.currentThread()
              */
            while (!atomicReference.compareAndSet(null, thread)) {
        
    
            }
        }
    
        public void myUnLock() {
        
            // 获取当前线程
            Thread thread = Thread.currentThread();
            // 解锁当前线程
            atomicReference.compareAndSet(thread, null);
            System.out.println(Thread.currentThread().getName() + "\t invoked myUnLock()");
        }
    
        public static void main(String[] args) {
        
            // 原子引用线程
            SpinLockDemo spinLockDemo = new SpinLockDemo();
    
            new Thread(() -> {
        
                spinLockDemo.myLock(); // 加锁
                try {
        
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                spinLockDemo.myUnLock(); // 解锁
            }, "AA").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(() -> {
        
                spinLockDemo.myLock(); // 加锁
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                spinLockDemo.myUnLock(); // 解锁
            }, "BB").start();
        }
    }

*  程序运行结果：核心为 CAS 算法
    
     *  线程 A 先执行，此时期望值为 null ，线程 A 将获得锁，并将期望值设置为线程 A 自身
     *  线程 B 尝试获取锁，发现期望值并不是 null ，就在那儿原地自旋
     *  线程 A 释放锁之后，将期望值设置为 null ，此时线程 B 获得锁，将期望值设置为线程 B 自身
     *  最后线程 B 释放锁

AA	 come in 
    BB	 come in 
    AA	 invoked myUnLock()
    BB	 invoked myUnLock()

### 5.4、读写锁 ###

> **独占锁（写锁）、共享锁（读锁）、互斥锁**

1.  **独占锁**：指该锁一次只能被一个线程所持有。对ReentrantLock和synchronized而言都是独占锁
2.  **共享锁**：指该锁可以被多个线程所持有
3.  对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。
4.  读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

> **读写锁的代码示例**

*  代码：使用 ReentrantReadWriteLock 完成读锁、写锁分离

/**
     * 多个线程同时读一个资源类没有问题，所以为了满足并发量，读取共享资源应该可以同时进行。
     *
     * 但是写资源只能有一个线程。
     *
     * 写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断。
     *
     * 小总结：
     * 读-读能共存
     * 读-写不能共存
     * 写-写不能共存
     *
     * 写操作：原子性+独占，整个过程必须是一个完整的统一体，中间不许被分隔，被打断
     *
     * @ClassName ReadWriteLockDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 14:13
     * @Version 1.0
     */
    public class ReadWriteLockDemo {
        
        public static void main(String[] args) {
        
            MyCache myCache = new MyCache();
            for (int i = 1; i <= 5; i++) {
        
                int tempInt = i;
                new Thread(() -> {
        
                    myCache.put(tempInt + "", tempInt + "");
                }, String.valueOf(i)).start();
            }
    
            for (int i = 1; i <= 5; i++) {
        
                int tempInt = i;
                new Thread(() -> {
        
                    myCache.get(tempInt + "");
                }, String.valueOf(i)).start();
            }
        }
    }
    
    class MyCache {
        
        // 凡缓存，一定要用 volatile 修饰，保证内存可见性
        private volatile Map<String, Object> map = new HashMap<>();
        // ReentrantReadWriteLock：读写锁
        private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    
        public void put(String key, Object value) {
        
            reentrantReadWriteLock.writeLock().lock(); // 加写锁
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
                try {
        
                    TimeUnit.MILLISECONDS.sleep(300); // 模拟网络传输，暂停线程一会儿
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                map.put(key, value);
                System.out.println(Thread.currentThread().getName() + "\t 写入完成");
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                reentrantReadWriteLock.writeLock().unlock(); // 释放写锁
            }
        }
    
        public void get(String key) {
        
            reentrantReadWriteLock.readLock().lock(); // 加读锁
            try {
        
                System.out.println(Thread.currentThread().getName() + "\t 正在读取：" + key);
                try {
        
                    TimeUnit.MILLISECONDS.sleep(300); // 模拟网络传输，暂停线程一会儿
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                Object result = map.get(key);
                System.out.println(Thread.currentThread().getName() + "\t 读取完成" + result);
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                reentrantReadWriteLock.readLock().unlock(); // 释放读锁
            }
        }
    }

*  程序运行结果：写操作没有被打断

2	 正在写入：2
    2	 写入完成
    3	 正在写入：3
    3	 写入完成
    1	 正在写入：1
    1	 写入完成
    4	 正在写入：4
    4	 写入完成
    5	 正在写入：5
    5	 写入完成
    1	 正在读取：1
    2	 正在读取：2
    3	 正在读取：3
    4	 正在读取：4
    5	 正在读取：5
    2	 读取完成2
    4	 读取完成4
    1	 读取完成1
    5	 读取完成5
    3	 读取完成3

--------------------

*  在ReentrantReadWriteLock中分别维护了一把读锁和一把写锁

public class ReentrantReadWriteLock
            implements ReadWriteLock, java.io.Serializable {
        
        private static final long serialVersionUID = -6992448646407690164L;
        /** Inner class providing readlock */
        private final ReentrantReadWriteLock.ReadLock readerLock;
        /** Inner class providing writelock */
        private final ReentrantReadWriteLock.WriteLock writerLock;
        /** Performs all synchronization mechanics */
        final Sync sync;

## 6、线程通信 ##

> **CountDownLatch、CyclicBarrier、Semaphore使用过吗？**

### 6.1、CountDownLatch ###

> **CountDownLatch 的用法**

1.  让一些线程阻塞，直到另一些线程完成一系列操作后才被唤醒
2.  CountDownLatch 维护了一个计数器，有两个核心方法：`countDown()` 和 `await()`
    
     *  调用 `countDown()` 方法会将计数器减一
     *  当计数器的值不为零时，线程调用 `await()` 方法时，会被阻塞
     *  当计数器的值变为0时，因调用 `await()` 方法被阻塞的线程会被唤醒，继续执行

> **CountDownLatch 代码示例**

*  代码

/**
     * @ClassName CountDownLatchDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 17:43
     * @Version 1.0
     */
    public class CountDownLatchDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            leaveClassroom();
        }
    
        private static void leaveClassroom() throws InterruptedException {
        
            CountDownLatch countDownLatch = new CountDownLatch(6); // 初始化次数为 6
            for (int i = 1; i <= 6; i++) {
        
                new Thread(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "\t上完自习，离开教室");
                    countDownLatch.countDown(); // 计数器减 1
                }, String.valueOf(i)).start();
            }
            countDownLatch.await(); // 等待上述线程执行完成（等待计数减为 0）
            System.out.println(Thread.currentThread().getName() + "\t ******班长最后关门走人");
        }
    }

*  程序运行结果：班长等待所有同学都完成自习后，再锁门

2	上完自习，离开教室
    1	上完自习，离开教室
    3	上完自习，离开教室
    4	上完自习，离开教室
    5	上完自习，离开教室
    6	上完自习，离开教室
    main	 ******班长最后关门走人

> **CountDownLatch + 枚举类的使用**

*  定义枚举类：可以通过 CountryEnum.ONE 获得齐国对应的 CountryEnum 对象

/**
     * @ClassName CountryEnum
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 17:44
     * @Version 1.0
     */
    public enum CountryEnum {
        
        ONE(1, "齐"), TWO(2, "楚"), THREE(3, "燕"), FOUR(4, "赵"), FIVE(5, "魏"), SIX(6, "韩");
    
        private Integer retCode;
        private String retMsg;
    
        CountryEnum(Integer retCode, String retMsg) {
        
            this.retCode = retCode;
            this.retMsg = retMsg;
        }
    
        public Integer getRetCode() {
        
            return retCode;
        }
    
        public void setRetCode(Integer retCode) {
        
            this.retCode = retCode;
        }
    
        public String getRetMsg() {
        
            return retMsg;
        }
    
        public void setRetMsg(String retMsg) {
        
            this.retMsg = retMsg;
        }
    
        public static CountryEnum list(int idx) {
        
            // 获取枚举类中的所有值
            CountryEnum[] countryEnums = CountryEnum.values();
            for (CountryEnum countryEnum : countryEnums) {
        
                if (idx == countryEnum.getRetCode()) {
        
                    return countryEnum;
                }
            }
            return null;
        }
    }

*  秦灭六国，后一统华夏

/**
     * @ClassName CountDownLatchDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 17:43
     * @Version 1.0
     */
    public class CountDownLatchDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            county();
        }
    
        private static void county() throws InterruptedException {
        
            CountDownLatch countDownLatch = new CountDownLatch(6); // 初始化次数为 6
            for (int i = 1; i <= 6; i++) {
        
                new Thread(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "\t 国被灭");
                    countDownLatch.countDown(); // 计数器减 1
                }, CountryEnum.list(i).getRetMsg()).start();
            }
            countDownLatch.await(); // 等待上述线程执行完成（等待计数减为 0）
            System.out.println(Thread.currentThread().getName() + "\t ******秦国一统华夏");
        }
    }

*  程序运行结果

齐	 国被灭
    魏	 国被灭
    燕	 国被灭
    楚	 国被灭
    韩	 国被灭
    赵	 国被灭
    main	 ******秦国一统华夏

### 6.2、CyclicBarrier ###

> **CyclicBarrier 的使用**

1.  CyclicBarrier 字面意思是可循环使用的屏障。它要做的事情是，让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会打开，所有被屏障拦截的线程才会继续干活
2.  通过 CyclicBarrie r的 await() 方法，使线程进入屏障
3.  CountDownLatch 是减，而 CyclicBarrier 是加，理解了CountDownLatch，CyclicBarrier 就很容易
4.  一句话总结：集齐7颗龙珠召唤神龙

> **CyclicBarrier 代码示例**

*  代码

/**
     * @ClassName CyclicBarrierDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 18:52
     * @Version 1.0
     */
    public class CyclicBarrierDemo {
        
        public static void main(String[] args) {
        
            CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
        
                System.out.println("召唤神龙"); // 龙珠收集完成，召唤神龙
            });
    
            for (int i = 1; i <= 7; i++) {
        
                final int tempInt = i;
                new Thread(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "\t 收集到第：" + tempInt + "龙珠");
                    try {
        
                        cyclicBarrier.await(); // 等待龙珠收集完成
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
        
                        e.printStackTrace();
                    }
    
                }, String.valueOf(i)).start();
            }
        }
    }

*  程序运行结果（感觉像是线程完成后的回调函数）

2	 收集到第：2龙珠
    3	 收集到第：3龙珠
    1	 收集到第：1龙珠
    6	 收集到第：6龙珠
    5	 收集到第：5龙珠
    4	 收集到第：4龙珠
    7	 收集到第：7龙珠
    召唤神龙

### 6.3、Semaphore ###

> **Semaphore 的使用**

1.  Semaphore 即信号量，信号量主要用于两个目的，**一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制**。
2.  构造器 `Semaphore(int)` 用于指定共享资源的数目，如果设定为 1 ，则 Semaphore 信号量退化为 Lock 锁或者 synchronized 锁
3.  调用 `semaphore.acquire()` 方法获取对共享资源的使用，调用 `semaphore.release()` 释放对共享资源的占用
4.  一句话讲明白：抢车位

> **Semaphore 代码示例**

*  代码：使用 Semaphore 完成对共享资源的并发控制

/**
     * @ClassName SemaphoreDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 19:02
     * @Version 1.0
     */
    public class SemaphoreDemo {
        
        public static void main(String[] args) {
        
            Semaphore semaphore = new Semaphore(3); // 模拟3个车位
            for (int i = 1; i <= 6; i++) {
         // 模拟6部车
                new Thread(() -> {
        
                    try {
        
                        semaphore.acquire(); // 尝试抢车位（获取信号量）
                        System.out.println(Thread.currentThread().getName() + "\t抢到车位");
                        try {
        
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "\t停车3秒后离开车位");
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    } finally {
        
                        semaphore.release(); // 释放车位（释放信号量）
                    }
                }, String.valueOf(i)).start();
            }
        }
    }

*  程序运行结果

2	抢到车位
    1	抢到车位
    3	抢到车位
    3	停车3秒后离开车位
    2	停车3秒后离开车位
    1	停车3秒后离开车位
    5	抢到车位
    6	抢到车位
    4	抢到车位
    4	停车3秒后离开车位
    6	停车3秒后离开车位
    5	停车3秒后离开车位

## 7、阻塞队列 ##

> **阻塞队列知道吗？**

### 7.1、什么是阻塞队列 ###

> **队列 + 阻塞队列**

1.  阻塞队列，顾名思义，首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如下图所示
2.  **当阻塞队列是满时，往队列里添加元素的操作将会被阻塞。当队列是空时，从队列中取出元素的操作将被阻塞**
3.  试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。
4.  试图往己满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程从列中移除一个或者多个元素，或者完全清空队列后使队列重新变得空闲起来并后续新增一些元素

![image-20200808193853566][]

### 7.2、阻塞队列好处 ###

> **为什么用阻塞队列？有什么好处？**

1.  在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒
2.  为什么需要BlockingQueue？**好处是我们不需要关心什么时候需要阻塞线程，不用我们自己去控制线程的唤醒（notify）和阻塞（wait）**
3.  什么时候需要唤醒线程？这一切BlockingQueue都给你一手包办了
4.  在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度

### 7.3、阻塞队列分类 ###

> **BlockingQueue 分类（看前三个即可）**

1.  **ArrayBlockingQueue**：由数组结构组成的有界阻塞队列——对应于 ArrayList
2.  **LinkedBlockingQueue**：由链表结构组成的有界（大小默认值为Integer.MAX\_VALUE）阻塞队列——对应于 LinkedList
3.  **SynchronousQueue**：不存储元素的阻塞队列，也即单个元素的队列——生产一个，消费一个
4.  PriorityBlockingQueue：支持优先级排序的无界阻塞队列
5.  DelayQueue：使用优先级队列实现的延迟无界阻塞队列
6.  LinkedTransferQueue：由链表结构组成的无界阻塞队列。
7.  LinkedBlockingDeque：由链表结构组成的双向阻塞队列

### 7.4、阻塞队列用法 ###

> **BlockingQueue 的核心方法**

<table> 
 <thead> 
  <tr> 
   <th>方法类型</th> 
   <th>抛出异常</th> 
   <th>返回布尔</th> 
   <th>阻塞</th> 
   <th>超时</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>插入</td> 
   <td>add(E e)</td> 
   <td>offer(E e)</td> 
   <td>put(E e)</td> 
   <td>offer(E e,Time,TimeUnit)</td> 
  </tr> 
  <tr> 
   <td>取出</td> 
   <td>remove()</td> 
   <td>poll()</td> 
   <td>take()</td> 
   <td>poll(Time,TimeUnit)</td> 
  </tr> 
  <tr> 
   <td>队首</td> 
   <td>element()</td> 
   <td>peek()</td> 
   <td>无</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

--------------------

**抛出异常**

1.  当阻塞队列满时，再往队列里add插入元素会抛IllegalStateException:Queue full
2.  当阻塞队列空时，再往队列里remove移除元素会抛NoSuchElementException

--------------------

**返回布尔**

1.  插入方法，成功 ture 失败 false
2.  移除方法，成功返回出队列的元素，队列里面没有就返回null

--------------------

**一直阻塞**

1.  当阻塞队列满时，生产者线程继续往队列里put元素，队列会一直阻塞生产线程直到put数据成功或者响应中断退出。
2.  当阻塞队列空时，消费者线程试图从队列里take元素，队列会一直阻塞消费者线程直到队列可用。

--------------------

**超时退出**

当阻塞队列满时，队列会阻塞生产者线程一定时间，超过后限时后生产者线程会退出

#### 7.4.1、ArrayBlockingQueue ####

**代码示例**

/**
     * ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列，此队列按FIFO原则对元素进行排序
     * LinkedBlockingQueue:是一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量高于ArrayBlockingQueue
     * SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移出操作，否则插入操作一直处于阻塞状态，吞吐量通常要高
     *
     * 阻塞队列
     *   1.阻塞队列有没有好的一面
     *   2.不得不阻塞，你如何管理
     *
     * @ClassName BlockingQueueDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 19:11
     * @Version 1.0
     */
    public class BlockingQueueDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);
            //addAndRemove(blockingQueue);
            //offerAndPoll(blockingQueue);
            //putAndTake(blockingQueue);
            outOfTime(blockingQueue);
        }
    
        private static void addAndRemove(BlockingQueue<String> blockingQueue) {
        
            System.out.println(blockingQueue.add("a"));
            System.out.println(blockingQueue.add("b"));
            System.out.println(blockingQueue.add("c"));
            System.out.println(blockingQueue.add("e"));
            System.out.println(blockingQueue.element());
            System.out.println(blockingQueue.remove());
            System.out.println(blockingQueue.remove());
            System.out.println(blockingQueue.remove());
            System.out.println(blockingQueue.remove());
        }
    
        private static void offerAndPoll(BlockingQueue<String> blockingQueue) {
        
            System.out.println(blockingQueue.offer("a"));
            System.out.println(blockingQueue.offer("b"));
            System.out.println(blockingQueue.offer("c"));
            System.out.println(blockingQueue.offer("e"));
            System.out.println(blockingQueue.peek());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
        }
    
        private static void putAndTake(BlockingQueue<String> blockingQueue) throws InterruptedException {
        
            blockingQueue.put("a");
            blockingQueue.put("b");
            blockingQueue.put("c");
            blockingQueue.put("d");
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
        }
    
        private static void outOfTime(BlockingQueue<String> blockingQueue) throws InterruptedException {
        
            System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
        }
    
    }

#### 7.4.2、SynchronousQueue ####

> **阻塞队列之 SynchronousQueue**

1.  SynchronousQueue没有容量。与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue。
2.  每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
3.  一句话总结：SynchronousQueue 时零库存阻塞队列

--------------------

**代码示例**

*  代码

/**
     * 阻塞队列SynchronousQueue演示
     *
     * @ClassName SynchronousQueueDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 20:13
     * @Version 1.0
     */
    public class SynchronousQueueDemo {
        
        public static void main(String[] args) {
        
            BlockingQueue<String> blockingQueue = new SynchronousQueue<>();
    
            new Thread(() -> {
        
                try {
        
                    System.out.println(Thread.currentThread().getName() + "\t put 1");
                    blockingQueue.put("1");
                    System.out.println(Thread.currentThread().getName() + "\t put 2");
                    blockingQueue.put("2");
                    System.out.println(Thread.currentThread().getName() + "\t put 3");
                    blockingQueue.put("3");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }, "AAA").start();
    
            new Thread(() -> {
        
                try {
        
                    try {
        
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
    
                    try {
        
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
    
                    try {
        
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }, "BBB").start();
        }
    }

*  程序运行结果：线程 AAA 生产完新的数据后，必须等待线程 BBB 取走后，才能继续生产

AAA	 put 1
    BBB	1
    AAA	 put 2
    BBB	2
    AAA	 put 3
    BBB	3

### 7.5、阻塞队列使用场景 ###

> **阻塞队列使用场景**

**生产者消费者模式、线程池、消息中间件**

> **传统版：消费者生产者模式**

*  代码：
    
     *  Lock 替代 synchronized
     *  `lock.await()` 替代 `object.wait()`
     *  `lock.signalAll()` 替代 `object.notifyAll()`

/**
     * 题目：一个初始值为0的变量，两个线程对其交替操作，一个加1，一个减1，来5轮
     *
     * 口诀：
     *  1.线程操作资源类     --> 编写方法
     *  2.判断 干活 通知     --> await() 和 signalAll()
     *  3.防止虚假唤醒机制   --> 使用 while 判断，而不是 if
     *
     * @ClassName ProdConsumer_TraditionDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 20:26
     * @Version 1.0
     */
    public class ProdConsumer_TraditionDemo {
        
        public static void main(String[] args) {
        
            ShareData shareData = new ShareData();
    
            new Thread(() -> {
        
                for (int i = 1; i <= 5; i++) {
        
                    try {
        
                        shareData.increment();
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
                }
            }, "AAA").start();
    
            new Thread(() -> {
        
                for (int i = 1; i <= 5; i++) {
        
                    try {
        
                        shareData.decrement();
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
                }
            }, "BBB").start();
        }
    }
    
    // 资源类
    class ShareData {
        
        private int number = 0;
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        public void increment() throws InterruptedException {
        
            lock.lock();
            try {
        
                //1 判断
                while (number == 1) {
        
                    //等待，不能生产
                    condition.await();
                }
                //2 干活
                number++;
                System.out.println(Thread.currentThread().getName() + "\t" + number);
                //3 通知唤醒
                condition.signalAll();
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    
        public void decrement() throws InterruptedException {
        
            lock.lock();
            try {
        
                //1 判断
                while (number == 0) {
        
                    //等待，不能生产
                    condition.await();
                }
                //2 干活
                number--;
                System.out.println(Thread.currentThread().getName() + "\t" + number);
                //3 通知唤醒
                condition.signalAll();
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    }

*  程序运行结果

AAA	1
    BBB	0
    AAA	1
    BBB	0
    AAA	1
    BBB	0
    AAA	1
    BBB	0
    AAA	1
    BBB	0

> **补充：synchronized 和Lock有什么区别？用新的Lock有什么好处？你举例说说**

**1、实现方式**：https://www.cnblogs.com/lycroseup/p/7486860.html

1.  synchronized是关键字属天JVM层面，synchronized的语义底层是通过一个monitor的对象来完成，其实`wait()`、`notify()`等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用`wait()`、`notify()`等方法，否则会抛出`java.lang.IllegalMonitorStateException`的异常的原因
2.  Lock是具体类（java.util.concurrent.Locks.Lock）是api层面的锁

--------------------

**2、使用方法**

1.  synchronized 不需要用户去手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用
2.  ReentrantLock则需要用户去手动释放锁着没有主动放锁，就有可能导致出现死锁现象。需要`lock()`和`unlock()`方法配合`try{ }finally{ }`语句块来完成。

--------------------

**3、等待是否可中断**

1.  synchronized不可中断，除非抛出异常或者正常运行完成
2.  ReentrantLock 可中断
    
     *  设置超时方法 `trylock(long timeout，TimeUnit unit)`
     *  或者
     *  `LockInterruptibly()`放代码块中，调用interrupt()方法可中断

--------------------

**4、加锁是否公平**

1.  synchronized非公平锁
2.  ReentrantLock两者都可以，默认公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁

--------------------

**5、锁绑定多个条件condition**

1.  synchronized没有
2.  ReentrantLock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

--------------------

**从字节码来看 synchronized 和 Lock**

*  代码

public static void main(String[] args) {
        
        synchronized (new Object()) {
        
        }
    
        ReentrantLock lock = new ReentrantLock();
    }

*  字节码指令
    
     *  有一条 monitorenter 指令，表示获取锁
     *  有两条 monitorexit 指令，其中第二条 monitorexit 指令保证程序出了一场，照样能释放锁
     *  使用 ReentrantLock 类，在字节码层面就是 new 了一个对象

0 new #2 <java/lang/Object>
     3 dup
     4 invokespecial #1 <java/lang/Object.<init>>
     7 dup
     8 astore_1
     9 monitorenter
    10 aload_1
    11 monitorexit
    12 goto 20 (+8)
    15 astore_2
    16 aload_1
    17 monitorexit
    18 aload_2
    19 athrow
    20 new #3 <java/util/concurrent/locks/ReentrantLock>
    23 dup
    24 invokespecial #4 <java/util/concurrent/locks/ReentrantLock.<init>>
    27 astore_1
    28 return

--------------------

> **题目：多线程交替打印，展示 Lock 的精确唤醒**

*  代码

/**
     * 题目：多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下：
     * A打印5次，B打印10次，C打印15次
     * 紧接着
     * A打印5次，B打印10次，C打印15次
     * ......
     * 打印10轮
     *
     * @ClassName SyncAndReenLockDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 21:01
     * @Version 1.0
     */
    public class SyncAndReentrantLockDemo {
        
        public static void main(String[] args) {
        
            ShareResource shareResource = new ShareResource();
    
            new Thread(() -> {
        
                for (int i = 1; i <= 10; i++) {
        
                    shareResource.print5();
                }
            }, "A").start();
            new Thread(() -> {
        
                for (int i = 1; i <= 10; i++) {
        
                    shareResource.print10();
                }
            }, "B").start();
            new Thread(() -> {
        
                for (int i = 1; i <= 10; i++) {
        
                    shareResource.print15();
                }
            }, "C").start();
        }
    }
    
    // 资源类
    class ShareResource {
        
        private int number = 1;//A:1.B:2,C:3
        private Lock lock = new ReentrantLock();
        private Condition c1 = lock.newCondition();
        private Condition c2 = lock.newCondition();
        private Condition c3 = lock.newCondition();
    
        public void print5() {
        
            lock.lock();
            try {
        
                //1判断
                while (number != 1) {
        
                    c1.await();
                }
                //2干活
                for (int i = 1; i <= 5; i++) {
        
                    System.out.println(Thread.currentThread().getName() + "\t" + i);
                }
                //3通知
                number = 2;
                c2.signal();
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    
        public void print10() {
        
            lock.lock();
            try {
        
                //1判断
                while (number != 2) {
        
                    c2.await();
                }
                //2干活
                for (int i = 1; i <= 10; i++) {
        
                    System.out.println(Thread.currentThread().getName() + "\t" + i);
                }
                //3通知
                number = 3;
                c3.signal();
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    
        public void print15() {
        
            lock.lock();
            try {
        
                //1判断
                while (number != 3) {
        
                    c3.await();
                }
                //2干活
                for (int i = 1; i <= 15; i++) {
        
                    System.out.println(Thread.currentThread().getName() + "\t" + i);
                }
                //3通知
                number = 1;
                c1.signal();
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    }

*  程序运行结果（一下结果仅是一轮打印的结果）

A	1
    A	2
    A	3
    A	4
    A	5
    B	1
    B	2
    B	3
    B	4
    B	5
    B	6
    B	7
    B	8
    B	9
    B	10
    C	1
    C	2
    C	3
    C	4
    C	5
    C	6
    C	7
    C	8
    C	9
    C	10
    C	11
    C	12
    C	13
    C	14
    C	15

> **阻塞队列版：消费者生产者模式**

*  代码

/**
     * volatile/CAS/atomicInteger/BlockQueue/线程交互/原子引用
     *
     * @ClassName ProdConsumer_BlockQueueDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 21:26
     * @Version 1.0
     */
    public class ProdConsumer_BlockQueueDemo {
        
        public static void main(String[] args) throws Exception {
        
            MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
    
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + "\t 生产线程启动");
                try {
        
                    myResource.myProd();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }, "Prod").start();
    
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + "\t 消费线程启动");
                try {
        
                    myResource.myConsumer();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }, "Consumer").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(5);
            }catch (InterruptedException e){
        
    
            }
    
            System.out.println("5秒钟到，main停止");
            myResource.stop();
        }
    }
    
    class MyResource {
        
        private volatile boolean FLAG = true; // 默认开启，进行生产 + 消费
        private AtomicInteger atomicInteger = new AtomicInteger();
    
        BlockingQueue<String> blockingQueue = null; // 通配、适用：传接口，不能传具体实现类
    
        public MyResource(BlockingQueue<String> blockingQueue) {
        
            this.blockingQueue = blockingQueue;
            System.out.println(blockingQueue.getClass().getName()); // 查看接口具体的落地实现类名称
        }
    
        public void myProd() throws Exception {
        
            String data = null;
            boolean retValue;
            while (FLAG) {
        
                data = atomicInteger.incrementAndGet() + ""; // 原子整形对象加 1
                retValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS); // 将数据放入阻塞队列
                if (retValue) {
        
                    System.out.println(Thread.currentThread().getName() + "\t插入队列" + data + "成功");
                } else {
        
                    System.out.println(Thread.currentThread().getName() + "\t插入队列" + data + "失败");
                }
                TimeUnit.SECONDS.sleep(1);
            }
            System.out.println(Thread.currentThread().getName() + "\t生产停止");
        }
    
        public void myConsumer() throws Exception {
        
            String result = null;
            while (FLAG) {
        
                result = blockingQueue.poll(2L, TimeUnit.SECONDS); // 从阻塞队列中取出数据
                if (null == result || result.equalsIgnoreCase("")) {
        
                    FLAG = false;
                    System.out.println(Thread.currentThread().getName() + "\t 超过2秒，消费退出");
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "\t消费队列" + result + "成功");
            }
            System.out.println(Thread.currentThread().getName() + "\t消费停止");
        }
    
        public void stop() throws Exception {
        
            this.FLAG = false; // 停止生产与消费
        }
    }

*  程序运行结果

java.util.concurrent.ArrayBlockingQueue
    Prod	 生产线程启动
    Consumer	 消费线程启动
    Prod	插入队列1成功
    Consumer	消费队列1成功
    Prod	插入队列2成功
    Consumer	消费队列2成功
    Prod	插入队列3成功
    Consumer	消费队列3成功
    Prod	插入队列4成功
    Consumer	消费队列4成功
    Prod	插入队列5成功
    Consumer	消费队列5成功
    5秒钟到，main停止
    Prod	生产停止
    Consumer	 超过2秒，消费退出

## 8、线程池 ##

> **线程池用过吗？ThreadPoolExecutor他谈你的理解？生产上你如何设置合理参数？**

### 8.1、Callable 接口 ###

**Callable 与 Futuretask（适配器模式）**

*  代码

/**
     * @ClassName CallableDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 21:51
     * @Version 1.0
     */
    public class CallableDemo {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
            new Thread(futureTask, "AA").start(); // 开始执行耗时计算
            int result01 = 100;
            // 等待线程执行完成
            while (!futureTask.isDone()){
        
                // Do something here
            }
            // 要求获得Callable线程的计算结果，如果没有计算完成就要去强求，会导致阻塞，直到计算完成
            int result02 = futureTask.get();
            System.out.println("result=" + (result01 + result02));
        }
    }
    
    class MyThread implements Callable<Integer> {
        
        @Override
        public Integer call() throws Exception {
        
            System.out.println("callable come in ...");
            // 模拟耗时操作
            try {
        
                TimeUnit.SECONDS.sleep(2);
            }catch (InterruptedException e){
        
    
            }
            return 1024;
        }
    }

*  程序运行结果

callable come in ...
    result=1124

--------------------

**多个线程共享 Futuretask**

*  代码：线程 A 和线程 B 共享 Futuretask

/**
     * @ClassName CallableDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 21:51
     * @Version 1.0
     */
    public class CallableDemo {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
            new Thread(futureTask, "AA").start(); // 开始执行耗时计算
            new Thread(futureTask, "BB").start(); // 开始执行耗时计算
            int result01 = 100;
            while (!futureTask.isDone()){
        
                // Do something here
            }
            // 要求获得Callable线程的计算结果，如果没有计算完成就要去强求，会导致阻塞，直到计算完成
            int result02 = futureTask.get();
            System.out.println("result=" + (result01 + result02));
        }
    }
    
    class MyThread implements Callable<Integer> {
        
        @Override
        public Integer call() throws Exception {
        
            System.out.println("callable come in ...");
            // 模拟耗时操作
            try {
        
                TimeUnit.SECONDS.sleep(2);
            }catch (InterruptedException e){
        
    
            }
            return 1024;
        }
    }

*  程序运行结果

callable come in ...
    result=1124

### 8.2、线程池的优势 ###

> **为什么要用线程池，线程池的优势是什么？**

线程池做的工作**主要是控制运行的线程的数量**，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

--------------------

线程池的主要特点为：线程复用；控制最大并发数；管理线程。

1.  第一：**降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
2.  第二：**提高响应速度**。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3.  第三：**提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

### 8.3、线程池如何使用 ###

> **线程池架构说明**

1.  Java 中的线程池是通过Executor框架实现的
2.  该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个类
3.  线程池框架架构图如下：

![image-20200808224121229][]

> **线程池的编码实现**

**了解：**

1.  `Executor：newScheduledThreadPool()`，带时间调度的线程池
2.  `Executors.newWorkStealingPool(int)`：java8新增，使用目前机器上可用的处理器作为它的并行级别

--------------------

**重要：**

1.  `Executors.newFixedThreadPool(int)`：执行长期的任务，性能好很多
2.  `Executors.newSingleThreadExecutor()`：一个任务一个任务执行的场景
3.  `Executors.newCachedThreadPool()`：执行很多短期异步的小程序或者负载较轻的服务器

--------------------

**线程池使用步骤：**

1.  创建线程池
2.  使用线程池
3.  关闭线程池

> **Executors.newFixedThreadPool(int)：固定线程数量的线程池**

**主要特点如下：**

1.  创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
2.  `newFixedThreadPool()` 创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的**LinkedBlockingQueue** 阻塞队列

public static ExecutorService newFixedThreadPool(int nThreads) {
        
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

--------------------

**代码示例**

*  代码

/**
     * 第四种使用Java多线程的方式：线程池
     *
     * @ClassName MyThreadPoolDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 22:34
     * @Version 1.0
     */
    public class MyThreadPoolDemo {
        
        public static void main(String[] args) {
        
            System.out.println("Fixed Thread Pool");
            fixedThreadPool();
        }
    
        private static void fixedThreadPool() {
        
            //一池5个线程
            ExecutorService threadPool = Executors.newFixedThreadPool(5);
            //一般常用try-catch-finally
            //模拟10个用户来办理业务，每个用户就是一个线程
            try {
        
                for (int i = 0; i < 9; i++) {
        
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "\t办理业务");
                    });
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    }

*  程序运行结果：线程池数量为 5，所以线程名最大为 pool-1-thread-5

Fixed Thread Pool
    pool-1-thread-3	办理业务
    pool-1-thread-4	办理业务
    pool-1-thread-2	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-2	办理业务
    pool-1-thread-4	办理业务
    pool-1-thread-5	办理业务
    pool-1-thread-3	办理业务
    pool-1-thread-1	办理业务

> **Executors.newSingleThreadExecutor()：单个线程的线程池**

**主要特点如下：**

1.  创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。
2.  `newSingleThreadExecutor()`将线程池的corePoolSize和maximumPoolSize都设置为1，它使用的**LinkedBlockingQueue** 阻塞队列

public static ExecutorService newSingleThreadExecutor() {
        
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

--------------------

**代码示例**

*  代码

/**
     * 第四种使用Java多线程的方式：线程池
     *
     * @ClassName MyThreadPoolDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 22:34
     * @Version 1.0
     */
    public class MyThreadPoolDemo {
        
        public static void main(String[] args) {
        
            System.out.println("Single Thread Pool");
            singleThreadPool();
        }
    
        private static void singleThreadPool() {
        
            //一池1个线程
            ExecutorService threadPool = Executors.newSingleThreadExecutor();
            try {
        
                for (int i = 0; i < 9; i++) {
        
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "\t办理业务");
                    });
                }
    
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    
    }

*  程序运行结果：线程池中只有一个线程

Single Thread Pool
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务
    pool-1-thread-1	办理业务

> **Executors.newCachedThreadPool()：自适应线程数量的线程**

**主要特点如下：**

1.  创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2.  `newCachedThreadPool()`将线程池的corePoolSize设置为0，将线程池的maximumPoolSize设置为`Integer.MAX_VALUE`，使用的**SynchronousQueue**，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程

public static ExecutorService newCachedThreadPool() {
        
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

--------------------

**代码示例**

*  代码

/**
     * 第四种使用Java多线程的方式：线程池
     *
     * @ClassName MyThreadPoolDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 22:34
     * @Version 1.0
     */
    public class MyThreadPoolDemo {
        
        public static void main(String[] args) {
        
            System.out.println("Cached Thread Pool");
            cachedThreadPool();
        }
    
        private static void cachedThreadPool() {
        
            //不定量线程
            ExecutorService threadPool = Executors.newCachedThreadPool();
            try {
        
                for (int i = 0; i < 9; i++) {
        
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "\t办理业务");
                    });
                }
    
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    
    }

*  程序运行结果

Cached Thread Pool
    pool-1-thread-1	办理业务
    pool-1-thread-2	办理业务
    pool-1-thread-3	办理业务
    pool-1-thread-4	办理业务
    pool-1-thread-5	办理业务
    pool-1-thread-6	办理业务
    pool-1-thread-7	办理业务
    pool-1-thread-8	办理业务
    pool-1-thread-3	办理业务

> **new ThreadPoolExecutor()**

![image-20200809101037147][]

### 8.4、线程池 7 大参数 ###

> **ThreadPoolExecutor 构造器**

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

> **七大参数**

1.  **corePoolSize**：线程池中的常驻核心线程数
    
     *  在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程
     *  当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中
2.  **maximumPoolSize**：线程池能够容纳同时执行的最大线程数，此数值必须大于等于1
3.  **keepAliveTime**：多余的空闲线程的存活时间。当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止
4.  **unit**：keepAliveTime的单位
5.  **workQueue**：任务队列，被提交但尚未被执行的任务（阻塞队列）
6.  **threadFactory**：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可
7.  **handler**：拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数时，如何来拒绝

--------------------

**理解：线程池的创建参数，就像一个银行。**

1.  corePoolSize就像银行的“当值窗口“，比如今天有2位柜员在受理客户请求（任务）。如果超过2个客户，那么新的客户就会在等候区（等待队列workQueue）等待。
2.  当等候区也满后，又来了几位客户，这个时候就要开启“加班窗口”，让其它3位柜员来加班，此时达到最大窗口maximumPoolSize，为5个。emmm …，但后来的客户会抢占等候区客户的机会，先办理业务
3.  如果开启了所有窗口，等候区依然满员，此时就应该启动”拒绝策略“handler，告诉不断涌入的客户，叫他们不要进入，已经爆满了。
4.  由于不再涌入新客户，加班窗口逐渐开始空闲，这个时候就通过keepAlivetTime将多余的3个”加班窗口“取消，恢复到2个”当值窗口“。

--------------------

**验证从core扩容到maximum后，立即运行当前到达的任务，而不是队列中的**

*  代码：线程池的核心线程数量为 2，最大线程数量为 5

/**
     * @ClassName T1
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/7 12:54
     * @Version 1.0
     */
    public class T1 {
        
    
        public static void main(String[] args) {
        
            ExecutorService threadPool = new ThreadPoolExecutor(
                    2,
                    5,
                    100,
                    TimeUnit.SECONDS,
                    new LinkedBlockingDeque<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy()
            );
            try {
        
                for (int i = 1; i <= 8; i++) {
        
                    final int tempInt = i;
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "号窗口，服务顾客" + tempInt);
                        try {
        
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    });
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    }

*  程序运行结果

pool-1-thread-2号窗口，服务顾客2
    pool-1-thread-1号窗口，服务顾客1
    pool-1-thread-3号窗口，服务顾客6
    pool-1-thread-4号窗口，服务顾客7
    pool-1-thread-5号窗口，服务顾客8
    pool-1-thread-1号窗口，服务顾客3
    pool-1-thread-2号窗口，服务顾客4
    pool-1-thread-5号窗口，服务顾客5

*  分析结果：core=2，所以1号窗口对应1号顾客，2号窗口对应2号顾客，但是接下来，3、4、5号顾客又来了，进入容量为3的队列中排队，接下来6、7、8号顾客又来了，1、2号窗口正在服务，且队列也满了，此时应该开启3、4、5号窗口来提供服务，为6、7、8号顾客提供服务，然后再由这5个窗口为3、4、5号顾客提供服务

### 8.5、线程池底层原理 ###

1.  在创建了线程池后，等待提交过来的任务请求。
2.  当调用execute()方法添加一个请求任务时，线程池会做如下判断：
    
     *  **如果正在运行的线程数量小于corePoolSize**，那么马上创建线程运行这个任务；
     *  如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
     *  **如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize**，那么还是要创建非核心线程立刻运行这个任务；
     *  **如果队列满了且正在运行的线程数量大于或等于maximumPoolSize**，那么线程池会启动饱和拒绝策略来执行。
3.  当一个线程完成任务时，它会从队列中取下一个任务来执行。
4.  当一个线程无事可做超过一定的时间（keepAliveTime）时，线程池会判断：
    
     *  如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉
     *  所以线程池的所有任务完成后它**最终会收缩到corePoolSize的大小**

![image-20200809104826668][]

### 8.6、线程池面试题 ###

#### 8.6.1、线程池拒绝策略 ####

> **拒绝策略是什么？**

1.  等待队列也已经排满了，再也塞不下新任务了，同时线程池中的max线程也达到了，无法继续为新任务服务。
2.  这时候我们就需要拒绝策略机制合理的处理这个问题。

> **JDK内置拒绝策略（以下内置策略均实现了RejectedExecutionHandler接口）**

1.  **AbortPolicy**（默认）：直接抛出RejectedExecutionException异常阻止系统正常运行
2.  **CallerRunsPolicy**：调用者运行，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退给调用者，从而降低新任务的流量
3.  **DiscardOldestPolicy**：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
4.  **DiscardPolicy**：直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案

#### 8.6.2、创建线程池方法 ####

> **单一的、固定的、可变的三种创建线程池的方法，用哪个多？**

**结论：一个都不用，答案来自于阿里开发手册**

--------------------

**【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。**

说明：使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

--------------------

**【强制】线程池不允许使用Executors 去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。**

说明：Executors返回的线程池对象的弊端如下：

1.  FixedThreadPool和SingleThreadPool：允许的请求队列长度为**Integer.MAX\_VALUE**，可能会堆积大量的请求，从而导致OOM。
2.  CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX\_VALUE，可能会创建大量的线程，从而导致OOM。

#### 8.6.3、自己手写线程池 ####

> **工作中如何使用线程池，是否自定义过线程池使用？**

*  JDK 自带线程池的缺陷：底层使用了 LinkedBlockingQueue 阻塞队列，该阻塞队列默认是**无界**的，允许的请求队列长度为Integer.MAX\_VALUE

![image-20200809112612639][]

/**
     * Creates a {@code LinkedBlockingQueue} with a capacity of
     * {@link Integer#MAX_VALUE}.
     */
    public LinkedBlockingQueue() {
        
        this(Integer.MAX_VALUE);
    }

--------------------

**代码示例：指令阻塞队列上限 + 使用默认的 AbortPolicy 策略**

*  代码

/**
     * 第四种使用Java多线程的方式：线程池
     *
     * @ClassName MyThreadPoolDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/8 22:34
     * @Version 1.0
     */
    public class MyThreadPoolDemo {
        
        public static void main(String[] args) {
        
            System.out.println("Custom Thread Pool\n");
            customThreadPool();
    
        }
    
        private static void customThreadPool() {
        
            ExecutorService threadPool =
                    new ThreadPoolExecutor(2,
                            5,
                            1L,
                            TimeUnit.SECONDS,
                            new LinkedBlockingQueue<>(3),
                            Executors.defaultThreadFactory(),
                            new ThreadPoolExecutor.AbortPolicy()
                    );
            try {
        
                for (int i = 1; i <= 8; i++) {
        
                    final int temp = i;
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "\t办理业务" + temp);
                    });
                }
    
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    }

*  for (int i = 1; i <= 8; i++) 时，线程池最大线程数 + 阻塞队列数量 = 8 ，所以程序不会抛异常，线程池 hold 得住

Custom Thread Pool
    
    pool-1-thread-1	办理业务1
    pool-1-thread-1	办理业务3
    pool-1-thread-1	办理业务4
    pool-1-thread-1	办理业务5
    pool-1-thread-2	办理业务2
    pool-1-thread-5	办理业务8
    pool-1-thread-3	办理业务6
    pool-1-thread-4	办理业务7

*  for (int i = 1; i <= 8; i++) 时，同时并发的最大线程数可能会超过 8 ，所以程序可能会抛异常，也可能不会，跑不跑异常，就看线程池能不能即时处理我们交给他的任务

Custom Thread Pool
    
    java.util.concurrent.RejectedExecutionException: Task com.Heygo.MyThreadPoolDemo$$Lambda$1/990368553@7ba4f24f rejected from java.util.concurrent.ThreadPoolExecutor@3b9a45b3[Running, pool size = 5, active threads = 2, queued tasks = 0, completed tasks = 6]
    	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
    	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
    	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
    	at com.Heygo.MyThreadPoolDemo.customThreadPool(MyThreadPoolDemo.java:40)
    	at com.Heygo.MyThreadPoolDemo.main(MyThreadPoolDemo.java:23)
    pool-1-thread-2	办理业务2
    pool-1-thread-3	办理业务6
    pool-1-thread-2	办理业务3
    pool-1-thread-2	办理业务5
    pool-1-thread-5	办理业务8
    pool-1-thread-1	办理业务1
    pool-1-thread-4	办理业务7
    pool-1-thread-3	办理业务4

--------------------

**代码示例：使用 CallerRunsPolicy 策略**

*  代码

private static void customThreadPool() {
        
        ExecutorService threadPool =
                new ThreadPoolExecutor(2,
                        5,
                        1L,
                        TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(3),
                        Executors.defaultThreadFactory(),
                        new ThreadPoolExecutor.CallerRunsPolicy()
                );
        try {
        
            for (int i = 1; i <= 9; i++) {
        
                final int temp = i;
                threadPool.execute(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "\t办理业务" + temp);
                });
            }
    
        } catch (Exception e) {
        
            e.printStackTrace();
        } finally {
        
            threadPool.shutdown();
        }
    }

*  程序运行结果：无法处理的任务会回退给调用线程

Custom Thread Pool
    
    pool-1-thread-1	办理业务1
    pool-1-thread-3	办理业务6
    pool-1-thread-2	办理业务2
    pool-1-thread-3	办理业务4
    pool-1-thread-1	办理业务3
    main	办理业务9
    pool-1-thread-5	办理业务8
    pool-1-thread-4	办理业务7
    pool-1-thread-2	办理业务5

--------------------

**代码示例：使用 DiscardOldestPolicy 策略**

*  代码

private static void customThreadPool() {
        
        ExecutorService threadPool =
                new ThreadPoolExecutor(2,
                        5,
                        1L,
                        TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(3),
                        Executors.defaultThreadFactory(),
                        new ThreadPoolExecutor.DiscardOldestPolicy()
                );
        try {
        
            for (int i = 1; i <= 9; i++) {
        
                final int temp = i;
                threadPool.execute(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "\t办理业务" + temp);
                });
            }
    
        } catch (Exception e) {
        
            e.printStackTrace();
        } finally {
        
            threadPool.shutdown();
        }
    }

*  程序运行结果：等待时间最长的业务 3 被抛弃了。。。

Custom Thread Pool
    
    pool-1-thread-1	办理业务1
    pool-1-thread-3	办理业务6
    pool-1-thread-1	办理业务4
    pool-1-thread-2	办理业务2
    pool-1-thread-1	办理业务9
    pool-1-thread-5	办理业务8
    pool-1-thread-4	办理业务7
    pool-1-thread-3	办理业务5

--------------------

**代码示例：使用 DiscardPolicy 策略**

*  代码

private static void customThreadPool() {
        
        ExecutorService threadPool =
                new ThreadPoolExecutor(2,
                        5,
                        1L,
                        TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(3),
                        Executors.defaultThreadFactory(),
                        new ThreadPoolExecutor.DiscardPolicy()
                );
        try {
        
            for (int i = 1; i <= 9; i++) {
        
                final int temp = i;
                threadPool.execute(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "\t办理业务" + temp);
                });
            }
    
        } catch (Exception e) {
        
            e.printStackTrace();
        } finally {
        
            threadPool.shutdown();
        }
    }

*  程序运行结果：业务 9 直接来吃闭门羹

Custom Thread Pool
    
    pool-1-thread-1	办理业务1
    pool-1-thread-3	办理业务6
    pool-1-thread-2	办理业务2
    pool-1-thread-1	办理业务3
    pool-1-thread-4	办理业务7
    pool-1-thread-5	办理业务8
    pool-1-thread-2	办理业务5
    pool-1-thread-3	办理业务4

#### 8.6.4、合理配置线程池 ####

> **如何查看机器的逻辑处理器个数**

`System.out.println(Runtime.getRuntime().availableProcessors());`

> **如何合理配置线程池？**

**CPU 密集型**

1.  CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
2.  CPU密集任务只有在真正的多核CPU上才可能得到加速（通过多线程），而在单核CPU上无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些。
3.  CPU密集型任务配置尽可能少的线程数量，一般公式：CPU核数+1个线程的线程池

**IO 密集型**

1.  由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如CPU核数\*2。
2.  IO密集型，即该任务需要大量的IO，即大量的阻塞。
3.  在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。
4.  所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
5.  IO密集型时，大部分线程都阻塞，故需要多配置线程数：参考公式：CPU核数/(1-阻塞系数)，阻塞系数在0.8~0.9之间，比如8核CPU：8/(1-0.9)=80个线程数

## 9、死锁及定位 ##

> **死锁编码及定位分析**

### 9.1、什么是死锁 ###

> **产生死锁的主要原因**

死锁是指两个或两个以上的进程在执行过程中，**因争夺资源而造成的一种互相等待的现象**，若无外力干涉那它们都将无法推进下去，如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。

![image-20200809124531543][]

> **死锁产生原因**

1.  系统资源不足
2.  进程运行推进的顺序不合适
3.  资源分配不当

### 9.2、死锁示例代码 ###

> **死锁代码 Demo**

*  代码：两个线程线程持有自己的锁，同时又去抢对方的锁，emmm。。。不是说不让用字符串作为线程同步锁吗

/**
     * 死锁是指两个或者两个以上的进程在执行过程中，因抢夺资源而造成的一种互相等待的现象，
     * 若无外力干涉它们将都无法推进下去，如果系统资源充足，进程的资源请求都能够得到满足，
     * 死锁出现的可能性也就很低，否则就会因争夺有限的资源而陷入死锁。
     *
     * @ClassName DeadLockDemo
     * @Description TODO
     * @Author Heygo
     * @Date 2020/8/9 12:48
     * @Version 1.0
     */
    public class DeadLockDemo {
        
        public static void main(String[] args) {
        
            String lockA = "lockA";
            String lockB = "lockB";
    
            new Thread(new HoldLockThread(lockA, lockB), "ThreadAAA").start();
            new Thread(new HoldLockThread(lockB, lockA), "ThreadBBB").start();
    
            /*
             * windows下的java运行程序，也有类似ps的查看进程的命令，但是目前我们需要查看的只是java
             *
             * linux
             *          ps -ef|grep xxxx    ls -l查看当前进程的命令
             *
             * windows
             *          jps = java ps      jps -l
             *          jstack
             * */
        }
    }
    
    class HoldLockThread implements Runnable {
        
        private String lockA;
        private String lockB;
    
        public HoldLockThread(String lockA, String lockB) {
        
            this.lockA = lockA;
            this.lockB = lockB;
        }
    
        public void run() {
        
            // 持有自己的锁
            synchronized (lockA) {
        
                System.out.println(Thread.currentThread().getName() + "\t自己持有：" + lockA + "\t尝试获得：" + lockB);
                // 睡眠一会儿，保证另一个线程能持有自己的锁
                try {
        
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                // 还希望得到别人的锁
                synchronized (lockB) {
        
                    System.out.println(Thread.currentThread().getName() + "\t自己持有：" + lockB + "\t尝试获得：" + lockA);
                }
            }
        }
    }

*  程序运行结果

![image-20200809130141642][]

### 9.3、死锁解决方案 ###

> **如何排查死锁问题？**

1.  **jps**命令定位进程号
2.  **jstack**找到死锁查看

> **操作示例**

*  jps -l 查看产生死锁的进程号

C:\Users\Heygo\Desktop\Interview>jps -l
    29808 sun.tools.jps.Jps
    3824 org.jetbrains.jps.cmdline.Launcher
    25220
    8900 DeadLockDemo

*  jstack pid ：找到死锁

Found one Java-level deadlock:
    =============================
    "ThreadBBB":
      waiting to lock monitor 0x000000001c403158 (object 0x000000076b518a18, a java.lang.String),
      which is held by "ThreadAAA"
    "ThreadAAA":
      waiting to lock monitor 0x000000001c400ef8 (object 0x000000076b518a50, a java.lang.String),
      which is held by "ThreadBBB"
    
    Java stack information for the threads listed above:
    ===================================================
    "ThreadBBB":
            at HoldLockThread.run(DeadLockDemo.java:56)
            - waiting to lock <0x000000076b518a18> (a java.lang.String)
            - locked <0x000000076b518a50> (a java.lang.String)
            at java.lang.Thread.run(Thread.java:748)
    "ThreadAAA":
            at HoldLockThread.run(DeadLockDemo.java:56)
            - waiting to lock <0x000000076b518a50> (a java.lang.String)
            - locked <0x000000076b518a18> (a java.lang.String)
            at java.lang.Thread.run(Thread.java:748)
    
    Found 1 deadlock.

[image-20200807104915773]: /images/20221124/065b5602a38e423294ea511ba049a4ba.png
[image-20200807112939904]: /images/20221124/d1026d55fcb746c487580a0c4c3ab1d7.png
[image-20200807114105344]: /images/20221124/0577fc1b02ca4a2483b3edb5bf3b305b.png
[image-20200807143528418]: /images/20221124/c1ce311457924ce98290a8089c5590c1.png
[image-20200807145328566]: /images/20221124/10646d03081348fea348cd56fb8392b8.png
[image-20200807150125103]: /images/20221124/384b3f1a8713425db32e3b651dda5f79.png
[image-20200807151131161]: /images/20221124/611cc509194d466a9963bb35fe7d0d6d.png
[image-20200807170454109]: /images/20221124/aff7392594ad451eafa67f1ecd26bc27.png
[image-20200808113755556]: /images/20221124/382ddea73c354849bacd37663a8cff81.png
[image-20200808132913472]: /images/20221124/f2b275d0f8734a4bbe99ae3033792489.png
[image-20200808193853566]: /images/20221124/cce719e7f1f94c09bfdcf44dfc040f2b.png
[image-20200808224121229]: /images/20221124/36ec1816d590464abc90eb43a978a2f6.png
[image-20200809101037147]: /images/20221124/9132f53fdac747428a053ce7bd94e9bf.png
[image-20200809104826668]: /images/20221124/778e180bd1184347930279aac2ca29c3.png
[image-20200809112612639]: /images/20221124/331e9da1963746c0bacd2037e7e64678.png
[image-20200809124531543]: /images/20221124/14f5d215eb774828ba90dc8bef8457e7.png
[image-20200809130141642]: /images/20221124/f1b2ec070e8740478007a7f0d785e0f5.png