• JUC（java.util.concurrent）
  • 进程和线程
    • 进程：后台运行的程序（我们打开的一个软件，就是进程）
    • 线程：轻量级的进程，并且一个进程包含多个线程（同在一个软件内，同时运行窗口，就是线程）
  • 并发和并行
    • 并发：同时访问某个东西，就是并发
    • 并行：一起做某些事情，就是并行
• JUC下的三个包
  • java.util.concurrent
    • java.util.concurrent.atomic
    • java.util.concurrent.locks

      JUC多线程以及并发包

      1. 谈谈你对volatile的理解

      volatile是java虚拟机提供的轻量级的同步机制；volatile主要有以下三大特性：保证可见性、不保证原子性、禁止指令重排序；

      1.1 JMM

      JMM（Java Memory Model，Java内存模型），本身是一种抽象的概念 并不真实存在,它描述的是一组规则或规范。通过规范定制了程序中各个变量(包括实例字段,静态字段和构成数组对象的元素)的访问方式。JMM有三大特性：可见性、原子性、有序性
      JMM关于同步规定:

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

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

数据传输速率：硬盘 < 内存 < < cache < CPU
上面提到了两个概念：主内存 和 工作内存

• 主内存：就是计算机的内存，也就是经常提到的8G内存，16G内存
• 工作内存：但我们实例化 new student，那么 age = 25 也是存储在主内存中
  • 当同时有三个线程同时访问 student中的age变量时，那么每个线程都会拷贝一份，到各自的工作内存，从而实现了变量的拷贝

缓存一致性是什么？

为什么这里主线程中某个值被更改后，其它线程能马上知晓呢？其实这里是用到了总线嗅探技术
在说嗅探技术之前，首先谈谈缓存一致性的问题，就是当多个处理器运算任务都涉及到同一块主内存区域的时候，将可能导致各自的缓存数据不一。为了解决缓存一致性的问题，需要各个处理器访问缓存时都遵循一些协议，在读写时要根据协议进行操作，这类协议主要有MSI、MESI等等。

MESI：

当CPU写数据时，如果发现操作的变量是共享变量，即在其它CPU中也存在该变量的副本，会发出信号通知其它CPU将该内存变量的缓存行设置为无效，因此当其它CPU读取这个变量的时，发现自己缓存该变量的缓存行是无效的，那么它就会从内存中重新读取。

总线探嗅技术

那么如何发现读取的数据缓存是否失效呢？这里是用到了总线嗅探技术，就是每个处理器通过嗅探在总线上传播的数据来检查自己缓存值是否过期了，当处理器发现自己的缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置为无效状态，当处理器对这个数据进行修改操作的时候，会重新从内存中把数据读取到处理器缓存中。

总线风暴

总线嗅探技术有哪些缺点？
由于Volatile的MESI缓存一致性协议，需要不断的从主内存嗅探和CAS循环，无效的交互会导致总线带宽达到峰值。因此不要大量使用volatile关键字，至于什么时候使用volatile、什么时候用锁以及Syschonized都是需要根据实际场景的。

1.2 保证可见性

可见性是指当一个线程在本地修改了主内存中的共享变量并写回主内存后，需要通知其他线程主内存中的共享变量已经被修改，并重新读取。
写个例子证明可见性：

class MyNumber { 
    public volatile Integer number = 0;  // 如果不加volatile 那么写回主内存的时候其他线程是不可见的
    public void addTo100() {
        this.number = 100;
    }
}
public class VolatileDemo {
    public static void main(String[] args) {
        MyNumber mynumber = new MyNumber();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mynumber.addTo100();
            System.out.println(Thread.currentThread().getName() + "\t 修改了number = " + mynumber.number);
        }, "Thread A").start();
        // 第二个线程是我们的main线程
        while (mynumber.number == 0) {
            // 如果number等于0，那么main线程就一直在这里等待
        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over" + mynumber.number);
    }
}

1.3 原子性

原子性表示什么意思？——不可分割，完整性，也就是说线程正在做某个具体业务室，中间不可以被加塞或分割。需要整体完整，要么同时成功，要么同时失败。
案例演示volatile不保证原子性：

class MyNumber {
    public volatile Integer number = 0;  // 如果不加volatile 那么写回主内存的时候其他线程是不可见的
    public void addTo100() {
        this.number = 100;
    }
    // 请注意，此时number加了volatile关键字修饰
    public void addPlusPlus() {
        number++;
    }
}
/**
 * 验证volatile的可见性
 *  如果int number = 0 没有添加volatile关键字，则没有可见性
 *
 * 验证volatile不保证原子性
 *
 */
public class VolatileDemo {
    public static void main(String[] args) {
        MyNumber mynumber = new MyNumber();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    mynumber.addPlusPlus();
                }
            }, "Thread" + i).start();
        }
        // 需要等待上面20个线程全部计算完成后，再用main线程获取number的最终值
        // Thread.activeCount() 可以统计当前活跃线程数
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "\t finally number value" + mynumber.number);
    }
}

为什么volatile不保证原子性？

在多线程竞争的情况下，某个线程修改了本地变量值写入主内存之前可能会被挂起，同时另外一个线程将修改写入主内存（还没来得及通知其他线程时）当前线程紧接着也将自己的修改写入主内存，导致了数据的丢失。
因为有很多值在putfield这步写回去的时候可能线程的调度被挂起了，刚好也没有收到最新值的通知，有这么一个纳秒级别的时间差，一写就出现了写覆盖，就把人家的值覆盖掉了

如何解决原子性问题？

1. 可以加synchronized来解决不保证原子性问题，但是不推荐使用；

2. 可以使用java.util.concurrent.atomic包下的AtomicInteger(带原子性包装的整型类)来解决不保证原子性问题；（其通过CAS来保证原子性） ```java class MyNumber { public volatile Integer number = 0; // 如果不加volatile 那么写回主内存的时候其他线程是不可见的 public void addTo100() {

    this.number = 100;

   }

   // 请注意，此时number加了volatile关键字修饰 public void addPlusPlus() {

    number++;

   }

   // 通过原子性包装类来解决原子性问题 AtomicInteger atomicInteger = new AtomicInteger(); public void addMyAtomic() {

    atomicInteger.getAndIncrement();

   }

}

/**

• 验证volatile的可见性
• 如果int number = 0 没有添加volatile关键字，则没有可见性 *
• 验证volatile不保证原子性

• why-为什么不保证原子性 / public class VolatileDemo { public static void main(String[] args) {

  MyNumber mynumber = new MyNumber();
  for (int i = 0; i < 20; i++) {
      new Thread(() -> {
          for (int j = 0; j < 1000; j++) {
              mynumber.addPlusPlus();
              mynumber.addMyAtomic();
          }
      }, "Thread" + i).start();
  }
  // 需要等待上面20个线程全部计算完成后，再用main线程获取number的最终值
  // Thread.activeCount() 可以统计当前活跃线程数
  while (Thread.activeCount() > 2) {
      Thread.yield();
  }
  System.out.println(Thread.currentThread().getName() + "\t finally number value" + mynumber.number);
  System.out.println(Thread.currentThread().getName() + "\t finally atomicInteger value" + mynumber.atomicInteger);

  } } ```

  1.4 有序性

  指令重排序

  计算机在执行程序时,为了提高性能,编译器和处理器常常会做指令重排,一般分为以下3种：
  
  通俗解释——先把会做的题目做了，再做不会做的题目（代码执行顺序跟写的顺序不同）
  单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。(还是会重排，但不影响结果)
  处理器在进行重新排序是必须要考虑指令之间的数据依赖性。
  多线程环境中线程交替执行,由于编译器优化重排的存在,两个线程使用的变量能否保持一致性是无法确定的,结果无法预测。 ```java 案例1： public void mySort(){ int x=11;//语句1 int y=12;//语句2 x=x+5;//语句3 y=x*x;//语句4 } 实际执行顺序可能为： 1234 2134 1324 问题:请问语句4 可以重排后变成第一条码? 存在数据的依赖性 没办法排到第一个。

案例2： int a, b, x, y = 0; 线程1进行操作： x = a, b = 1; 线程2进行操作： y = b, a = 2; 最终结果 x = 0, y = 0 如果编译器对这段代码进行执行重排优化后,可能出现下列情况: 线程1：b = 1, x = a; 线程2：a = 2, y = b; 最终结果 x = 2, y = 1 这也就说明在多线程环境下,由于编译器优化重排的存在,两个线程使用的变量能否保持一致是无法确定的.

案例3： public class ReSortSeqDemo { int a = 0; boolean flag = true; public void method1() { a = 1; // 语句1 flag = true; // 语句2 } public void method2() { if (flag) { a = a + 5; // 语句3 System.out.println(“**retValue:” + a); } } } 多线程分别调用method1和method2的情况下，method1指令重排可能会导致语句2先执行， 此时其他的线程执行method2，得到的结果为5，而实际上我们想要的结果是6，因此需要静止指令重排

<a name="oLz3M"></a>
#### 小结
volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象<br />先了解一个概念，内存屏障(Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个:
- 一是保证特定操作的执行顺序。
- 二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。
由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。**内存屏障就是一段与平台相关的代码，Java中的内存屏障代码都在Unsafe类中定义，共包含三个方法：LoadFence()、storeFence()、fullFence()。**<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/22423156/1649424375640-1e2aab2e-2480-4cfa-a8b3-fd0cf7851ffb.png#clientId=u9bdb8641-81b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=485&id=u9ae7aa07&name=image.png&originHeight=485&originWidth=1214&originalType=binary&ratio=1&rotation=0&showTitle=false&size=267304&status=done&style=none&taskId=ud5f90562-f790-4678-925b-097829a38fd&title=&width=1214)
<a name="eOcgV"></a>
### 线程安全性得到满足
工作内存与主内存同步延迟现象导致的可见性问题<br />可以使用synchronized或volatile关键字解决，它们都可以使一个线程修改后的变量立即对其他线程可见。<br />对于指令重排导致的可见性问题和有序性问题<br />可以利用volatile关键字解决，因为volatile的另外一个作用就是禁止重排序优化。
<a name="Tx1rl"></a>
### 1.5 你在哪些地方使用到了volatile
<a name="rnpKL"></a>
#### 单例模式DCL（Double Check Lock）分析
```java
public class SingletonDemo {
    // private static SingletonDemo instance = null;
    // 如果在高并发多线程的版本里面，那么此时的单例模式最终的写法就是volatile + DCL
    private static volatile SingletonDemo instance = null;
    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName() + "\t 构造方法");
    }
    // DCL双捡锁机制
    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                if (instance == null) instance = new SingletonDemo();
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, "Thread" + i).start();
        }
    }
}

DCL机制不一定线程安全，原因是有指令重排序的存在，加入volatile可禁止指令重排序。
原因在于某一个线程在执行到第一次检测,读取到的instance不为null时,instance的引用对象可能没有完成初始化.
instance=new SingletonDem(); 可以分为以下步骤(伪代码)

memory=allocate();//1.分配对象内存空间
instance(memory);//2.初始化对象
instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null

步骤2和步骤3不存在数据依赖关系.而且无论重排前还是重排后程序执行的结果在单线程中并没有改变,因此这种重排优化是允许的.
memory=allocate();//1.分配对象内存空间
instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null 但对象还没有初始化完.
instance(memory);//2.初始化对象
但是指令重排只会保证串行语义的执行一致性(单线程) 并不会关心多线程间的语义一致性，所以当一条线程访问instance不为null时,由于instance实例未必完成初始化,也就造成了线程安全问题。

2. CAS

2.1 CAS是什么

• 如果线程的期望值跟物理内存的真实值一样，就更新值到物理内存当中，并返回true；
• 如果线程的期望值跟物理内存的真实值不一样，返回是false，那么本次修改失败，那么此时需要重新获得主物理内存的新值（自旋）

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

CASDemo

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        // main do thing ...
        System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t current data:" + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t current data:" + atomicInteger.get());
    }
}

2.2 CAS底层原理？Unsafe的理解？

CAS底层原理=自旋锁+Unsafe类
我们先看看atomicInteger.getAndIncrement()方法的源码，其使用的是unsafe类的getAndAddInt方法

Unsafe类

Unsafe类在jdk中的jre/lib/rt.jar包的sun.misc包下。

Unsafe是CAS的核心类 由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问,UnSafe相当于一个后面,基于该类可以直接操作特额定的内存数据.UnSafe类在于sun.misc包中,其内部方法操作可以向C的指针一样直接操作内存,因为Java中CAS操作的执行依赖于UNSafe类的方法。
注意UnSafe类中所有的方法都是native修饰的,也就是说UnSafe类中的方法都是直接调用操作底层资源执行响应的任务。
为什么Atomic修饰的包装类，能够保证原子性，依靠的就是底层的unsafe类
变量ValueOffset，便是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的；

详解CAS

变量value用volatile修饰,保证了多线程之间的可见性。

var5：就是我们从主内存中拷贝到工作内存中的值(每次都要从主内存拿到最新的值到自己的本地内存，然后执行compareAndSwapInt()再和主内存的值进行比较。因为线程不可以直接越过高速缓存，直接操作主内存，所以执行上述方法需要比较一次，再执行加1操作

• var1 AtomicInteger对象本身.
• var2 该对象值的引用地址
• var4 需要变动的数值
• var5 是用过var1 var2找出内存中真实的值
  • 用该对象当前的值与var5比较
  • 如果相同,更新var5+var4的值并且返回true
  • 如果不同,继续取值然后比较,直到更新完成。

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别在不同的CPU上):

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

   底层汇编

   Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于unsafe.cpp中 ```cpp UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv env,jobject unsafe , jobject obj, jlong offset ,jint e, jint x)) UnsafeWrapper(“Unsafe_CompareAndSwapInt”); oop p = JNIHandles::resolve(obj); jint addr = (jint *) index_oop_from_field_offset_long(p, offset); return (jint)(Atomic:.cmpxchg(x, addr, e)) == e; UNSAFE_END

- 先想办法拿到变量value在内存中的地址
- 通过Atomic::cmpxchg实现比较替换，其中参数X是即将更新的值，参数e是原内存的值
<a name="HlDWA"></a>
### 2.3 CAS的缺点
- 循环时间长开销大：上面getAndAddInt方法执行时有个do-while。如果CAS失败会一直进行尝试，如果CAS长时间一直不成功，可能会给CPU带来很大的开销。（怎么解决呢？ LongAdder）
- 只能保证一个共享变量的原子操作
   - 当对一个共享变量执行操作时，我们可以通过循环CAS的方式来保证原子操作
   - 但是对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候只能用锁来保证原子性
- ABA问题（引入版本号可以解决）
<a name="zDgZ1"></a>
### 2.4 总结
- CAS是compareAndSwap，比较当前工作内存中的值和主物理内存中的值，如果相同则执行规定操作，否者继续比较直到主内存和工作内存的值一致为止
- CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否者什么都不做
<a name="dSchN"></a>
### 2.5 LongAdder（CAS机制优化）
LongAdder是java8为我们提供的新的类，跟AtomicLong有相同的效果。是对CAS机制的优化，因为非常搞高并发的请求下AtomicLong的性能是不能让人接受的。<br />如下AtomicLong 的incrementAndGet的代码，虽然AtomicLong使用CAS算法，但是CAS失败后还是通过无限循环的自旋锁不多的尝试，这就是高并发下CAS性能低下的原因所在。源码如下：
```java
public final long incrementAndGet() {
    for (;;) {
        long current = get();
        long next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

核心思想：将热点数据分离。
比如说它可以将AtomicLong内部的内部核心数据value分离成一个数组，每个线程访问时，通过hash等算法映射到其中一个数字进行计数，而最终的计数结果则为这个数组的求和累加，其中热点数据value会被分离成多个单元的cell，每个cell独自维护内部的值。当前对象的实际值由所有的cell累计合成，这样热点就进行了有效地分离，并提高了并行度。这相当于将AtomicLong的单点的更新压力分担到各个节点上。在低并发的时候通过对base的直接更新，可以保障和AtomicLong的性能基本一致。而在高并发的时候通过分散提高了性能。

在LongAdder的底层实现中，首先有一个base值，刚开始多线程没有发生冲突进行数值累加时，都是对base进行累加的，比如刚开始累加成了base = 5。
接着如果发现并发更新的线程数量过多，在发生竞争的情况下，会有一个Cell数组用于将不同线程的操作离散到不同的节点上去 (会根据需要扩容，最大为CPU核）就会开始施行分段CAS的机制，也就是内部会搞一个Cell数组，每个数组是一个数值分段。
这样便可以让大量的线程分别去对不同Cell内部的value值进行CAS累加操作，这样就把CAS计算压力分散到了不同的Cell分段数值中了！而且他内部实现了自动分段迁移的机制，也就是如果某个Cell的value执行CAS失败了，那么就会自动去找另外一个Cell分段内的value值进行CAS操作。
这样也解决了线程空旋转、自旋不停等待执行CAS操作的问题，让一个线程过来执行CAS时可以尽快的完成这个操作。最后，如果你要从LongAdder中获取当前累加的总值，就会把base值和所有Cell分段数值加起来返回。
https://blog.csdn.net/jiangtianjiao/article/details/103844801
LongAdder维护了要给延迟初始化的原子性更新数组cells和一个基值变量base，数组的大小保持是2的N次方大小（最大为CPU线程数），数组表的下标使用每个线程的hashcode值的掩码表示，数组里面的变量实体是Cell类型。
Cell 类型是Atomic的一个改进，用来减少缓存的争用，对于大多数原子操作字节填充是浪费的，因为原子操作都是无规律的分散在内存中进行的，多个原子性操作彼此之间是没有接触的，但是原子性数组元素彼此相邻存放将能经常共享缓存行，也就是伪共享。所以这在性能上是一个提升。另外由于Cells占用内存是相对比较大的，所以一开始并不创建，而是在需要时候再创建，也就是惰性加载，当一开始没有空间时候，所有的更新都是操作base变量。

3. 原子类AtomicInteger的ABA问题，原子引用更新你知道吗？

从AtomicInteger引出下面的问题：
CAS -> Unsafe -> CAS底层思想 -> ABA -> 原子引用更新 -> 如何规避ABA问题

3.1 什么是ABA问题

假设现在有两个线程，分别是T1 和 T2，然后T1执行某个操作的时间为10秒，T2执行某个时间的操作是2秒，最开始AB两个线程，分别从主内存中获取A值，但是因为B的执行速度更快，他先把A的值改成B，然后在修改成A，然后执行完毕，T1线程在10秒后，执行完毕，判断内存中的值为A，并且和自己预期的值一样，它就认为没有人更改了主内存中的值，就快乐的修改成B，但是实际上 可能中间经历了 ABCDEFA 这个变换，也就是中间的值经历了狸猫换太子。
所以ABA问题就是，在进行获取主内存值的时候，该内存值在我们写入主内存的时候，已经被修改了N次，但是最终又改成原来的值了。（尽管CAS操作成功，但是不代表这个过程是没有问题的）

3.2 原子引用

原子引用其实和原子包装类是差不多的概念，就是将一个java类，用原子引用类进行包装起来，那么这个类就具备了原子性

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        User z3 = new User("z3", 22);
        User li4 = new User("li4", 25);
        // 创建User的原子引用包装类
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(z3); // 现在主物理内存的共享变量，为z3
        // 调用原子引用的compareAndSet，期望值是z3，如果没有被修改就更改为li4
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        // 比较并交换，现在主物理内存的值是li4了，但是预期为z3，因此交换失败
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
    }
}

3.3 原子引用+时间戳（AtomicStampedReference） 解决ABA问题

新增一种机制，也就是修改版本号，类似于时间戳的概念
T1： 100 1 2019 2
T2： 100 1 101 2 100 3
如果T1修改的时候，版本号为2，落后于现在的版本号3，所以要重新获取最新值，这里就提出了一个使用时间戳版本号，来解决ABA问题的思路。那么就引入了AtomicStampedReference 带时间戳的原子引用包装类

AtomicReference模拟ABA问题

我们先写个程序来模拟一下ABA问题：

public class ABADemo {  // ABA问题的解决  AtomicStampedReference
    // 普通原子引用包装类
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    public static void main(String[] args) {
        new Thread(() -> {
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "Thread 1").start();
        new Thread(() -> {
            try {  // t2 暂停1s，保证t1完成ABA操作
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 把100 改成 101 然后在改成100，也就是ABA
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get());
        }, "Thread 2").start();
    }
}

上面输出了true，也就是ABA问题

AtomicStampReference解决ABA问题

时间戳原子引用，来这里应用于版本号的更新，也就是每次更新的时候，需要比较期望值和当前值，以及期望版本号和当前版本号

public class ABADemo {
    // 普通原子引用包装类
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    // ABA问题的解决  AtomicStampedReference
    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 1);
    public static void main(String[] args) {
        System.out.println("=============以下是ABA问题的产生=================");
        new Thread(() -> {
            // 先把100改成101，再改回来 完成ABA
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "Thread 1").start();
        new Thread(() -> {
            try {  // t2 暂停1s，保证t1完成ABA操作
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 把100 改成 101 然后在改成100，也就是ABA
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get());
        }, "Thread 2").start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("=============以下是ABA问题的解决=================");
        new Thread(() -> {
            int stamp = stampedReference.getStamp();  // 获取初始版本号
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
            // 暂停1s t3 保证t4能够获取到相同的初始版本号
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 先把100改成101，再改回来 完成ABA
            stampedReference.compareAndSet(100, 101, stampedReference.getStamp(),stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t第2次版本号：" + stampedReference.getStamp());
            stampedReference.compareAndSet(101, 100,stampedReference.getStamp(),stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t第3次版本号：" + stampedReference.getStamp());
        }, "Thread 3").start();
        new Thread(() -> {
            int stamp = stampedReference.getStamp();  // 获取初始版本号
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
            // 暂停3s t4，保证t3完成一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean res = stampedReference.compareAndSet(100, 2019, stamp,stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\tt4修改：" + res + " 当前版本号：" + stampedReference.getStamp());
            System.out.println(Thread.currentThread().getName() + "\t当前最新值：" + stampedReference.getReference());
        }, "Thread 4").start();
    }
}

可以看到修改失败，ABA被解决了。

4. 集合类线程不安全问题

4.1 ArrayList不安全

public class ContainerNotSafeDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();  //底层Object[] elementData初始化为{}.并没创建长度为10的数组
        list.add("a");  // 第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, "Thread 1").start();
        }
    }
}

故障现象：

解决方案

1. 我们可以使用线程安全的集合类Vector，其add方法是同步方法（保证了数据一致性，但是访问性能下降）；
2. 使用Collections.synchronizedList(new ArrayList<>()) 创建一个线程安全的List （其实就是在add的时候使用了synchronized同步代码块）；
3. CopyOnWriteArrayList 写时复制ArrayList （多线程建议使用这个，lock加锁+写时复制）

我们可以看看CopyOnWriteArrayList中add方法的源码

private transient volatile Object[] array;
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();   // 获取当前List中的所有元素
        int len = elements.length;  
        Object[] newElements = Arrays.copyOf(elements, len + 1);  // 拷贝旧元素到新的扩容的数组中
        newElements[len] = e;  // 添加新的值
        setArray(newElements);  // 更新
        return true;
    } finally {
        lock.unlock();
    }
}

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

4.2 Set不安全

public class SetNotSafeDemo {
    public static void main(String[] args) {
        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(set);
            }, String.valueOf(i)).start();
        }
    }
}

这里说一下HashSet的源码，HashSet其实就是一个HashMap，HashSet的中存的值是HashMap的key，HashMap中的Value是一个固定对象PRESENT
上面这段代码同样会出现java.util.ConcurrentModificationException异常；同样可以使用Collections.synchronizedSet()和CopyOnWriteArraySet，其具体原理与List的一致（CopyOnWriteArraySet底层就是一个CopyOnWriteArrayList）。

4.3 Map不安全

public class MapNotSafeDemo {
    public static void main(String[] args) {
//        HashMap<String, String> map = new HashMap<>();
//        HashMap<String, String> map1 = (HashMap<String, String>) Collections.synchronizedMap(new HashMap<String, String>());
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}

同样HashMap也是线程不安全的，可以使用集合工具类Collections.synchronizedMap(new HashMap())和ConcurrentHashMap创建线程安全的HashMap；

ConcurrentHashMap底层原理

jdk 1.7 ：
数据结构：内部主要是一个Segment数组，而数组的每一项又是一个HashEntry数组，元素都存在HashEntry数组里。因为每次锁定的是Segment对象，也就是整个HashEntry数组，所以又叫分段锁。

jdk 1.8 ：
数据结构：与HashMap一样采用：数组+链表+红黑树

底层原理则是采用锁链表或者红黑树头结点，相比于HashTable的方法锁，力度更细，是对数组（table）中的桶（链表或者红黑树）的头结点进行锁定，这样锁定，只会影响数组（table）当前下标的数据，不会影响其他下标节点的操作，可以提高读写效率。putVal执行流程：

1. 判断存储的key、value是否为空，若为空，则抛出异常
2. 计算key的hash值，随后死循环（该循环可以确保成功插入，当满足适当条件时，会主动终止），判断table表为空或者长度为0，则初始化table表
3. 根据hash值获取table中该下标对应的节点，如果该节点为空，则根据参数生成新的节点，并以CAS的方式进行更新，并终止死循环。
4. 如果该节点的hash值是MOVED(-1)，表示正在扩容，则辅助对该节点进行转移。
5. 对数组（table）中的节点，即桶的头结点进行锁定，如果该节点的hash大于等于0，表示此桶是链表，然后对该桶进行遍历（死循环），寻找链表中与put的key的hash值相等，并且key相等的元素，然后进行值的替换，如果到链表尾部都没有符合条件的，就新建一个node，然后插入到该桶的尾部，并终止该循环遍历。
6. 如果该节点的hash小于0，并且节点类型是TreeBin，则走红黑树的插入方式。

7. 判断是否达到转化红黑树的阈值，如果达到阈值，则链表转化为红黑树。

   5. 锁

   5.1 公平锁/非公平锁

   公平锁：是指多个线程按照申请锁的顺序来获取锁类似排队打饭 先来后到公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第1个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己；
   非公平锁：是指在多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。（并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁 默认是非公平锁）
   Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁 默认是非公平锁 非公平锁的优点在于吞吐量比公平锁大，对于synchronized而言 也是一种非公平锁。

   5.2 可重入锁（递归锁）

   可重入锁(也叫做递归锁)，指的是同一线程外层函数获得锁之后﹐内层递归函数仍然能获取该锁的代码,在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。（某个类中有两个非静态同步方法，可以在一个同步方法中调用另一个同步方法，也就是说拿到一个锁后，这个锁锁定的所有方法都能调用）
   ReentrantLock/synchronized就是一个典型的可重入锁，可重入锁最大的作用就是避免死锁。

   可重入锁例子

   ```java class Phone implements Runnable { public synchronized void sendSms() throws Exception {

    System.out.println(Thread.currentThread().getName() + "\tsendSms");
    sendEmail();

   }

   public synchronized void sendEmail() throws Exception {

    System.out.println(Thread.currentThread().getName() + "\tsendEmail");

   }

   ReentrantLock lock = new ReentrantLock();

   @Override public void run() {

    get();

   }

   private void get() {

    lock.lock();
    lock.lock();  // 可以重复锁定
    try {
        System.out.println(Thread.currentThread().getName() + "\tget");
        set();
    } finally {
        lock.unlock();  // 但是一定要解锁
        lock.unlock();
    }

   }

   private void set() {

    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + "\tset");
    } finally {
        lock.unlock();
    }

   } }

/**

• @author mrlinxi
• @create 2022-04-10 19:49
• 可重入锁(也叫做递归锁)
• 指的是同一先生外层函数获得锁后,内层敌对函数任然能获取该锁的代码
• 在同一线程外外层方法获取锁的时候,在进入内层方法会自动获取锁

• 也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块 */ public class ReenterLockDemo { 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();

    Thread t3 = new Thread(phone);
    Thread t4 = new Thread(phone);
    t3.start();
    t4.start();
}

}

<a name="IkpeW"></a>
### 5.3 自旋锁
自旋锁：spinlock，是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。原来提到的比较并交换，底层使用的就是自旋，自旋就是多次尝试，多次访问，不会阻塞的状态就是自旋。<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/22423156/1649438297763-913a7019-5369-4e3a-b424-62daaef50a89.png#clientId=u9bdb8641-81b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=389&id=Kax7l&name=image.png&originHeight=389&originWidth=700&originalType=binary&ratio=1&rotation=0&showTitle=false&size=38301&status=done&style=none&taskId=u4688f68e-0fae-4e60-91e8-de5b07c5e4f&title=&width=700)<br />优点：循环比较获取直到成功为止，没有类似于wait的阻塞<br />缺点：当不断自旋的线程越来越多的时候，会因为执行while循环不断的消耗CPU资源
<a name="oSnbP"></a>
#### 手写一个自旋锁
通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁2秒，B随后进来发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
```java
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，更新值是当前线程，如果是null，则更新为当前线程，否者自旋
        while(!atomicReference.compareAndSet(null, thread)) {
            System.out.println(Thread.currentThread().getName() + "\t 自旋");
        }
    }
    public void myUnLock() {
        // 获取当前进来的线程
        Thread thread = Thread.currentThread();
        // 自己用完了后，把atomicReference变成null
        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(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        }, "Thread 1").start();
        new Thread(() -> {
            spinLockDemo.myLock();
            spinLockDemo.myUnLock();
        }, "Thread 2").start();
    }
}

5.4 独占锁(写)/共享锁(读)/互斥锁

独占锁:指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁；
共享锁:指该锁可被多个线程所持有。
对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

读写锁案例

// 资源类
class MyCache {
    private volatile HashMap<String, Object> map = new HashMap<>();
    ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    public void put(String key, Object value) {
        readWriteLock.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 {
            readWriteLock.writeLock().unlock();
        }
    }
    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t正在读取");
            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 {
            readWriteLock.readLock().unlock();
        }
    }
}
/**
 * @author mrlinxi
 * @create 2022-04-10 20:35
 * 多个线程同时操作 一个资源类没有任何问题 所以为了满足并发量
 *  * 读取共享资源应该可以同时进行
 *  * 但是
 *  * 如果有一个线程想去写共享资源来  就不应该有其他线程可以对资源进行读或写
 *  * <p>
 *  * 小总结:
 *  * 读 读能共存
 *  * 读 写不能共存
 *  * 写 写不能共存
 *  * 写操作 原子+独占 整个过程必须是一个完成的统一整体 中间不允许被分割 被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(Thread.currentThread().getName(), tempInt);
            }, "Thread " + i).start();
        }
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(Thread.currentThread().getName());
            }, "Thread " + i).start();
        }
    }
}

6. CountDownLatch/CyclicBarrier/Semaphore使用过吗?

6.1 CountDownLatch

让一些线程阻塞直到另外一些完成后才被唤醒，CountDownLatch主要有两个方法,当一个或多个线程调用await方法时,调用线程会被阻塞.其他线程调用countDown方法计数器减1(调用countDown方法时线程不会阻塞),当计数器的值变为0,因调用await方法被阻塞的线程会被唤醒,继续执行。

关门案例

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            final int tempInt = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t" + tempInt + "走了");
                countDownLatch.countDown();
            }, "Thread" + i).start();
        }
        countDownLatch.await();
        System.out.println("锁门");
    }
}

枚举的使用

@Getter
enum CountryEnum {
    ONE(1, "齐"),
    TWO(2, "楚"),
    THREE(3, "燕"),
    FOUR(4, "赵"),
    FIVE(5, "魏"),
    SIX(6, "韩");
    private Integer code;
    private String name;
    CountryEnum(Integer code, String name) {
        this.code = code;
        this.name = name;
    }
    public static CountryEnum forEach_CountryEnum(int index) {
        CountryEnum[] countryEnums = CountryEnum.values();
        for (CountryEnum countryEnum : countryEnums) {
            if (countryEnum.getCode().equals(index)) return countryEnum;
        }
        return null;
    }
}
/**
 * @author mrlinxi
 * @create 2022-04-10 21:02
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            final int tempInt = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t" + tempInt + "国被灭");
                countDownLatch.countDown();
            }, CountryEnum.forEach_CountryEnum(i).getName()).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + "**********秦国一统天下");
    }
}

6.2 CyclicBarrier

CyclicBarrier的字面意思是可循环(Cyclic) 使用的屏障(barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫做同步点)时被阻塞,知道最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活,线程进入屏障通过CyclicBarrier的await()方法。

收集龙珠案例

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> System.out.println("召唤神龙"));
        for (int i = 0; i < 7; i++) {
            final int temp = i + 1;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"\t 收集到第"+ temp +"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, "Thread" + i).start();
        }
    }
}

6.3 Semaphore

信号量的主要用户两个目的，一个是用于多个共享资源的相互排斥使用，另一个用于并发资源数的控制。

抢车位案例

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);  // 3个车位
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "\t抢到了车位");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t离开了了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, "Thread" + i).start();
        }
    }
}

7. 阻塞队列

阻塞队列是一个队列，在数据结构中起的作用如下图：

线程1往阻塞队列里添加元素，线程2从阻塞队列里移除元素
当队列是空的，从队列中获取元素的操作将会被阻塞；
当队列是满的，从队列中添加元素的操作将会被阻塞；
试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素；
试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增；

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

7.1 种类分析

• ArrayBlockingQueue：由数组结构组成的有界阻塞队列。
• LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列。
• PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
• DelayQueue：使用优先级队列实现的延迟无界阻塞队列。
• SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列。
  • SynchronousQueue没有容量，与其他BlcokingQueue不同,SynchronousQueue是一个不存储元素的BlcokingQueue。每个put操作必须要等待一个take操作,否则不能继续添加元素,反之亦然。
• LinkedTransferQueue：由链表组成的无界阻塞队列。
• LinkedBlockingDeque：由链表组成的双向阻塞队列。

7.2 BlockingQueue的核心方法

• 抛出异常：当阻塞队列满时，再往队列里add插入元素会抛IllegalStateException:Queue full；当阻塞队列空时，再往队列里remove移除元素会抛NoSuchElementException
• 特殊值：插入方法，成功ture失败false；移除方法，成功返回出队列的元素，队列里没有就返回null
• 一直阻塞：当阻塞队列满时，生产者线程继续往队列里put元素，队列会一直阻塞生产者线程直到put数据or响应中断退出；当阻塞队列空时，消费者线程试图从队列里take元素，队列会一直阻塞消费者线程直到队列可用

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

  7.3 SynchronousQueueDemo

  SynchronousQueue没有容量，与其他BlcokingQueue不同,SynchronousQueue是一个不存储元素的BlcokingQueue。每个put操作必须要等待一个take操作,否则不能继续添加元素,反之亦然。

  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();
            }
        }, "Thread A").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();
            }
        }, "Thread B").start();
    }
  }

  7.4 阻塞队列用在哪里

  阻塞队列可以用在：生产者消费者模式、线程池以及消息中间件中； ```java class ShareData { private int number = 0; private ReentrantLock lock = new ReentrantLock(); private Condition condition = lock.newCondition();

  public void increment() throws InterruptedException {

    lock.lock();
    try {
        while (number != 0) {  // 1. 判断
            condition.await();
        }
        number++;  // 2.干活
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        condition.signalAll();  // 3. 通知
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }

  }

  public void decrement() throws InterruptedException {

    lock.lock();
    try {
        while (number == 0) {  // 1. 判断
            condition.await();
        }
        number--;  // 2.干活
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        condition.signalAll();  // 3. 通知
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }

  } }

/**

• @author mrlinxi
• @create 2022-04-11 0:08
• 生产消费者模式传统版:一个初始值为零的变量，两个线程对齐交替操作，一个+1一个-1，来五轮
• 1 线程 操作 资源类
• 2 判断 干活 通知唤醒

• 3 防止虚假唤醒机制 */ public class ProdConsumerTraditionDemo { public static void main(String[] args) {

   ShareData data = new ShareData();
   new Thread(() -> {
       for (int i = 0; i < 5; i++) {
           try {
               data.increment();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }, "Thread A").start();
   new Thread(() -> {
       for (int i = 0; i < 5; i++) {
           try {
               data.decrement();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }, "Thread B").start();

  } } java class MyResource { private volatile boolean FLAG = true; // 默认开启进行生产+消费 private AtomicInteger atomicInteger = new AtomicInteger();

  BlockingQueue blockingQueue = null;

  public MyResource(BlockingQueue blockingQueue) {

   this.blockingQueue = blockingQueue;
   System.out.println(blockingQueue.getClass().getName());

  }

  public void myProduct() throws Exception {

   String data = null;
   boolean retValue;
   while (FLAG) {
       data = atomicInteger.incrementAndGet() + "";
       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 + "失败");
       }
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
   System.out.println(Thread.currentThread().getName() + "\t FLAG=false,生产工作结束");

  }

  public void myConsumer() throws Exception {

   String result = null;
   while (FLAG) {
       result = blockingQueue.poll(2L, TimeUnit.SECONDS);
       if (result == null || result.equalsIgnoreCase("")) {
           FLAG = false;
           System.out.println(Thread.currentThread().getName() + "\t 超过2s没有取到蛋糕，消费退出");
           break;
       }
       System.out.println(Thread.currentThread().getName() + "\t 消费阻塞队列" + result + "成功");
   }

  }

  public void stop() {

   this.FLAG = false;

  } }

/**

• @author mrlinxi
• @create 2022-04-11 0:14
• volatile/CAS/AtomicInteger/BlockQueue/线程交互/原子引用

• 生产消费者模式阻塞队列版:一个初始值为零的变量，两个线程对齐交替操作，一个+1一个-1，来五轮 */ public class ProdConsumerBlockQueueDemo { public static void main(String[] args) {

   MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
   new Thread(() -> {
       try {
           System.out.println(Thread.currentThread().getName() + "\t 生产线程启动");
           myResource.myProduct();
       } catch (Exception e) {
           e.printStackTrace();
       }
   }, "Thread Prod").start();
   new Thread(() -> {
       try {
           System.out.println(Thread.currentThread().getName() + "\t 消费线程启动");
           myResource.myConsumer();
       } catch (Exception e) {
           e.printStackTrace();
       }
   }, "Thread Consumer").start();
   try {
       TimeUnit.SECONDS.sleep(5);
   } catch (InterruptedException e) {
       e.printStackTrace();
   }
   System.out.println("================================");
   System.out.println("5s时间到，停止生产");
   myResource.stop();

  } } ```

  8. synchronized和Lock的区别？用lock有什么好处？

  | synchronized | lock | | —- | —- | | 1、synchronized是JVM层面，它是JAVA的关键字 | 1、Lock是API层面的具体类，它是java5以后新出的一个类 | | 2、synchronized是不需要手动释放锁，synchronized代码执行完以后，系统会自动让线程释放对锁的占用 | 2、lock就需要手动去释放锁，若没有主动的去释放锁，就可能导致死锁的现象 | | 3、synchronized不能中断，除非是抛出了异常或者是正常执行完成 | 3、lock是可以中断的，主要是设置超时的方法
  - 设置超时方法 tryLock(long timeout, TimeUnit unit)
  - lockInterruptibly()放代码块中，调用interrupt()方法可中断
  | | 4、synchronized是非公平锁 | 4、lock默认是非公平锁，但是也支持公平锁 | | 5、synchronized不支持精确唤醒，只能随机唤醒或者是唤醒全部线程 | 5、lock可支持精确唤醒 |

synchronized在字节码中是monitorenter和monitorexit（monitorexit有两个，一个是正常退出一个是异常退出）

/**
 * @author mrlinxi
 * @create 2022-04-11 0:32
 *  请您说说synchronized和Lock的区别？用lock有什么好处？
 *   synchronized是JVM层面，它是JAVA的关键字
 *   synchronized 是不需要手动释放锁，当synchronized代码执行完以后，系统会自动让线程释放对锁的占用
 *   synchronized不能中断，除非是抛出了异常或者是正常执行完成
 *   synchronized是非公平锁
 *   synchronized不支持精确唤醒，只能随机唤醒或者是唤醒全部线程
 *
 *   Lock是API层面的具体类，它是java5以后新出的一个类
 *   lock就需要手动去释放锁，若没有主动的去释放锁，就可能导致死锁的现象
 *   lock是可以中断的
 *      1. 设置超时方法 tryLock(long timeout, TimeUnit unit)
 *      2. lockInterruptibly()放代码块中，调用interrupt()方法可中断
 *   lock默认是非公平锁，但是也支持公平锁
 *   lock可支持精确唤醒
 *
 *   多线程之间按顺序调用，实现A->B->C 三个线程启动
 *   AA打印5次， BB打印10次，CC打印15次
 *   紧接着
 *   AA打印5次， BB打印10次，CC打印15次
 *   来十轮
 */
class ShareResource{
    private int number = 1;
    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{
            //判断
            while (number!=1){  //说明是首次线程进来
                c1.await(); //进来等着
            }
            //2.干活
            for (int i = 1; i <=5 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3.通知B线程
            number = 2;
            c2.signal();//通知b线程
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    //第二个线程
    public void print10(){
        lock.lock();
        try{
            //判断
            while (number!=2){  //说明是首次线程进来
                c2.await(); //进来等着
            }
            //2.干活
            for (int i = 1; i <=10 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3.通知B线程
            number = 3;
            c3.signal();//通知b线程
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    //第3个线程
    public void print15(){
        lock.lock();
        try{
            //判断
            while (number!=3){  //说明是首次线程进来
                c3.await(); //进来等着
            }
            //2.干活
            for (int i = 1; i <=15 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3.重新回去通知A线程
            number = 1;
            c1.signal();//通知A线程
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
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();
    }
}

9. Callable与Java线程池

获取多线程的方法，总共有四种：

• 实现Runnable接口
• 实现Callable接口
• 实例化Thread类

• 使用线程池获取

  9.1 Callable接口

  已经有Runnable接口，为什么还要出现Callable接口？请你谈谈它的诞生的前身背景？

• 因为并发，异步导致Callable接口的出现；

• 主要是用Callable，能够实现当多个任务执行当中，若有一个任务完成的耗时时间比较长，那么可以先将其他任务先完成，然后等待这个耗时比较长的任务结束以后一起进行总的计算

我们实现Callable接口，也需要实现call方法，但是这个时候我们还需要有返回值，这个Callable接口的应用场景一般就在于批处理业务，比如转账的时候，需要给一会返回结果的状态码回来，代表本次操作成功还是失败

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("*****************come in callable");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1024;
    }
}