JUC并发编程

JUC并发编程（初级）

1.juc中的概念

1.1 wait和sleep的区别

1. sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用。
2. sleep不会释放锁，它他也不需要占用锁。wait会释放锁，但它调用的前提是当前线程占有锁（即代码要在synchronized中）。
3. 它们都可以被interrupted方法中断。

1.2 并发与并行

1.2.1 串行模式

​ 串行是一次只能取得一个任务，并执行这个任务。

1.2.2 并行模式

​ 多个任务同时执行。

1.2.3 并发和并行

并发：

​ 同一时刻多个线程访问同一个资源，多个线程对一个点。

并行：

​ 多项工作一起执行，最后再汇总

1.3 管程（Monitor）

​ Monitor：监视器，就是我们所说的锁，是一种同步机制，保证同一个时间，只有一个线程能去访问被保护的数据或者代码，jvm同步是基于进入和退出，使用管程对象实现的。

1.4 用户线程和守护线程

**用户线程：**平时用到的线程基本都是用户线程（自定义的线程，比如new出来的线程）。

守护线程：

• 是一种特殊线程，运行在后台，比如垃圾回收。
• 可以用Thread.currenThread().isDaemon()来判断线程是不是守护线程，如果返回值为true，则该线程为守护线程，返回值为false则该线程不是守护线程。
• 主线程结束了，用户线程还在运行，jvm存活；如果没有用户线程在运行，那么即使守护线程在运行，jvm也可以退出，守护线程的唯一目的就是服务用户线程。

1.5 多线程编程的步骤

• 第一步：创建资源类，在资源类创建属性和操作方法。
• 第二步：在资源类操作方法中，进行以下三步
  • (1) 判断
  • (2) 干活
  • (3) 通知
• 第三步：创建多个线程，调用资源类的操作方法。
• 第四步：防止虚假唤醒问题。

2. lock接口

2.1 Synchronized关键字

1. 修饰一个代码块，被修饰的代码块称为同步代码块，其作用范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象；

2.2 lock和synchronized的区别

• lock不是Java语言内置的，synchronized是java语言的关键字，因此是内置的。lock是一个类，通过这个类可以实现同步访问。
• lock是手动锁，synchronized是自动锁。
• synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象的发生；而；lock在发生异常 时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象因此使用lock时需要在finally块中释放锁；
• lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能响应中断。
• 通过lock可以知道有没有成功获取锁，而synchronized却无法办到。
• lock可以提高多个线程进行读写的效率。

​ 从性能上来讲，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时lock的性能要远远优于synchronized。

2.3 线程的start()方法

​ 当线程调用start()方法的时候，线程不一定会被创建，它可能立马被创建，也可能过一会才会被创建，因为在start()方法内部会调用start0()方法，start0()方法是由native关键字修饰的，此时会去调用操作系统来完成，当操作系统空闲时，会立马创建线程，否则会过一会创建线程。

2.3.1native关键字

1.native是java中的一个关键字，在Java诞生的时候正是c跟c++盛行的时候，想要立足就得能够调用c跟c++的程序，native就是用来实现这个功能的。
2.凡是带了native关键字的，说明java的作用已经达不到了，会去调用底层库。
3.native关键字作用与方法上，并且不提供实现体（废话，肯定是其他语言实现的了），它会进入本地方法栈，通过调用JNI接口实现对其他语言代码和代码库的使用。
4.内存中有一块专门开辟的区域：Native Method Stack，登记Native方法。

2.4 lock

​ lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。采用 Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用 Lock 必须在 try{}catch{}块中进行，并且将释放锁的操作放在finally 块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用 Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = new ReentrantLock();
lock.lock();
try{
//处理任务
}catch(Exception ex){
}finally{
    lock.unlock(); //释放锁
}

2.4.1 newCondition

​ 关键字 synchronized 与 wait()/notify()这两个方法一起使用可以实现等待/通知模式， Lock 锁的 newContition()方法返回 Condition 对象，Condition 类也可以实现等待/通知模式。

用 notify()通知时，JVM 会随机唤醒某个等待的线程， 使用 Condition 类可以进行选择性通知， Condition 比较常用的两个方法：

​ • await()会使当前线程等待,同时会释放锁,当其他线程调用 signal()时,线程会重新获得锁并继续执行。

​ • signal()用于唤醒一个等待的线程。

注意：在调用 Condition 的 await()/signal()方法前，也需要线程持有相关的 Lock 锁，调用 await()后线程会释放这个锁，在 singal()调用后会从当前Condition 对象的等待队列中，唤醒 一个线程，唤醒的线程尝试获得锁， 一旦获得锁成功就继续执行。

2.4.2 ReentrantLock

​ ReentrantLock，意思是“可重入锁”，关于可重入锁的概念将在后面讲述。ReentrantLock 是唯一实现了 Lock 接口的类，并且 ReentrantLock 提供了更多的方法。

2.4.3 ReadWriteLock

ReadWriteLock 也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
 /**
 * Returns the lock used for reading.
 *
 * @return the lock used for reading.
 */
    Lock readLock();
 /**
 * Returns the lock used for writing.
 *
 * @return the lock used for writing.
 */
 Lock writeLock();
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成 2 个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的

ReentrantReadWriteLock 实现了 ReadWriteLock 接口。

ReentrantReadWriteLock 里面提供了很多丰富的方法，不过最主要的有两个

方法：readLock()和 writeLock()用来获取读锁和写锁。

注意: 可同时读，但是不能边读边写

• 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

• 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

3. 线程间的通信

3.1 虚假唤醒问题

​ wait()等待的特点：在哪里睡，就在哪里醒，所以在使用if判断时，就会出现虚假唤醒问题。如下代码：

public synchronized void add() throws Exception {
        //2、判断、通知、干活
        if (number != 0) { //判断number的值是否为0，如果不是0，等待
            this.wait();
        }
        //如果是number是0，就进行+1操作
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        //通知其他线程
        this.notifyAll();
    }

上述代码中，使用了if对number的值进行判断，当 number != 0 时，线程会在第五行进行等待，如果线程被唤醒，则会直接从第五行开始往下执行，不会进入if中对number的值进行判断，从而导致数据出现错误，这就是虚假唤醒。

要解决虚假唤醒问题，需要把判断的条件放在while循环中，这样当线程被唤醒之后，会继续执行循环判断。代码如下：

public synchronized void add() throws Exception {
        //2、判断、通知、干活
        while (number != 0) { //判断number的值是否为0，如果不是0，等待
            this.wait(); //wait()在那里睡就会在哪里醒
        }
        //如果是number是0，就进行+1操作
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        //通知其他线程
        this.notifyAll();
    }

4、线程间定制化通信

通过一个标志位进行指定线程的唤醒

package com.zh.lock;

import lombok.Data;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: zhang hao
 * @Date: 2022/12/14 15:27
 * @Description: 线程精准唤醒
 */

public class notify {
    public static void main(String[] args) {
        Test ticket = new Test();
        new Thread(()->{
            for (int i = 1; i <= 5; i++) {
                ticket.printA(i,"AA");
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <= 5; i++) {
                ticket.printB(i,"BB");
            }
        },"BB").start();
        new Thread(()->{
            for (int i = 1; i <= 5; i++) {
                ticket.printC(i,"CC");
            }
        },"CC").start();
    }

}

@Data
class Test{
    private int flag = 1;

    private Lock lock  = new ReentrantLock();

    private Condition condition = lock.newCondition();

    public void printA(int loop,String name){
        lock.lock();
        try {
            while (flag != 1){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "输出 "+name+",第" + loop + " 轮开始");
            //输出 5 次 A
            for (int i = 0; i < 5; i++) {
                System.out.println(name);
            }

            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "输出 ,第" + loop + " 轮前flag = " + flag);
            flag = (flag % 3) +1;
            System.out.println(Thread.currentThread().getName() + "输出 ,第" + loop + " 轮后flag = " + flag);
            lock.unlock();
        }
    }
    public void printB(int loop,String name){
        lock.lock();
        try {
            while (flag != 2){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "输出 "+name+",第" + loop + " 轮开始");
            //输出 5 次 A
            for (int i = 0; i < 5; i++) {
                System.out.println(name);
            }
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "输出 ,第" + loop + " 轮前flag = " + flag);
            flag = (flag % 3) +1;
            System.out.println(Thread.currentThread().getName() + "输出 ,第" + loop + " 轮后flag = " + flag);
            lock.unlock();
        }
    }
    public void printC(int loop,String name){
        lock.lock();
        try {
            while (flag != 3){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "输出 "+name+",第" + loop + " 轮开始");
            //输出 5 次 A
            for (int i = 0; i < 5; i++) {
                System.out.println(name);
            }
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "输出 ,第" + loop + " 轮前flag = " + flag);
            flag = (flag % 3) +1;
            System.out.println(Thread.currentThread().getName() + "输出 ,第" + loop + " 轮后flag = " + flag);
            lock.unlock();
        }
    }
}

5. 集合的线程安全

5.1 ArrayList 线程不安全

在ArrayList中，如果有多个线程同时存取数据，就会出现并发修改异常，原因是ArrayList的add和get方法上面没有上锁，所有他是一个线程不安全的。

5.2 Vector

Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。和 ArrayList 不同，Vector 中的操作是线程安全的。

5.3 Collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的。

List list = Collections.synchronizedList(new ArrayList<>());

5.4 CopyOnWriteArrayList(重点)

写时复制技术。支持并发读，写的时候先复制一个跟之前集合相同的集合，然后在新的集合中写入，写入完成后和原有的集合进行合并。

首先我们对 CopyOnWriteArrayList 进行学习,其特点如下:

它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和ArrayList 不同的时，它具有以下特性：

1. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。

2. 它是线程安全的。

3. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。

4. 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。

5. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

5.5 HashSet 和 HashMap 线程不安全

HashSet 中的方法也没有synchronized关键字，所以也是线程不安全的。HashSet的低层就是一个HashMap，它的值就是map的key，所以是不能重复的。

可以通过CopyOnWriteArraySet来解决HashSet线程不安全的问题

HashMap的方法中也没有synchronized关键字，所以也是线程不安全的，可以通过ConcurrentHashMap来解决HashMap线程不安全的问题

6. 多线程锁

6.1 锁的八个问题演示

class Phone {
 public static synchronized void sendSMS() throws Exception {
 //停留 4 秒
 TimeUnit.SECONDS.sleep(4);
 System.out.println("------sendSMS");
 }
 public synchronized void sendEmail() throws Exception {
 System.out.println("------sendEmail");
 }
 public void getHello() {
 System.out.println("------getHello");
 }
}

1 标准访问，先打印短信还是邮件

------sendSMS

------sendEmail

2 停 4 秒在短信方法内，先打印短信还是邮件

------sendSMS

------sendEmail

3 新增普通的 hello 方法，是先打短信还是 hello

------getHello

------sendSMS

4 现在有两部手机，先打印短信还是邮件

------sendEmail

------sendSMS

5 两个静态同步方法，1 部手机，先打印短信还是邮件

------sendSMS

------sendEmail

6 两个静态同步方法，2 部手机，先打印短信还是邮件

------sendSMS

------sendEmail

7 1 个静态同步方法,1 个普通同步方法，1 部手机，先打印短信还是邮件

------sendEmail

------sendSMS

8 1 个静态同步方法,1 个普通同步方法，2 部手机，先打印短信还是邮件

------sendEmail

------sendSMS

结论

• 一个对象里面如果有多个 synchronized 方法，某一个时刻内，只要一个线程去调用其中的一个 synchronized 方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized 方法锁的是当前对象 this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized 方法
• 加个普通方法后发现和同步锁无关
• 换成两个对象后，不是同一把锁了，情况立刻变化
• synchronized 实现同步的基础：Java 中的每一个对象都可以作为锁。

具体表现为以下 3 种形式。

对于普通同步方法，锁是当前实例对象。

对于静态同步方法，锁是当前类的 Class 对象。

对于同步方法块，锁是 Synchonized 括号里配置的对象

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁。

可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——类对象本身。

静态同步方法和非静态同步方法用的两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。

但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

6.2 公平锁和非公平锁

private Lock lock  = new ReentrantLock();
private Lock lock  = new ReentrantLock(false);

无参构造和参数为false的Lock锁就是非公平锁，非公平锁可能导致的情况就是资源一直被一个线程抢占，其他线程可能出现饿死的情况。

但是他的优点是线程执行的效率高。

private Lock lock  = new ReentrantLock(true);

参数为true时，Lock锁为公平锁，公平锁可以保证每个线程都可以得到资源，不会出现线程被饿死的情况。但是效率相对较低。

6.3 可重入锁（递归锁）

synchronized（隐式）和 Lock（显式）都是可重入锁

可重入锁就是某一层锁的内部有很多层代码都加锁时，如果进入了第一层代码，那么内部加锁的代码就也可以进入。

6.4 死锁

1、什么是死锁：

两个或两个以上的的线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，如果没有外力干涉，他们无法再执行下去。

2、产生死锁的原因：

• 系统资源不足
• 线程运行推进顺序不合适
• 资源分配不当

3、死锁发生的四个必要条件

• 互斥
• 占有且等待
• 不可抢占
• 多个线程形成循环等待链

4、死锁的验证

//控制台
  jps -l //查询出进程信息
 //查询进程中线程的详细信息  jstack是jvm自带的堆栈跟踪工具
 jstack 进程编号

7. Callable&Future 接口

创建线程的多种方式

1. 继承Thread类

   // 通过继承Thread类来创建线程类
   public class FirstThread extends Thread
   {
       private int i ;
       // 重写run方法，run方法的方法体就是线程执行体
       public void run()
       {
           for ( ; i < 100 ; i++ )
           {
               // 当线程类继承Thread类时，直接使用this即可获取当前线程
               // Thread对象的getName()返回当前该线程的名字
               // 因此可以直接调用getName()方法返回当前线程的名
               System.out.println(getName() +  " " + i);
           }
       }
       public static void main(String[] args)
       {
           for (int i = 0; i < 100;  i++)
           {
               // 调用Thread的currentThread方法获取当前线程
               System.out.println(Thread.currentThread().getName()
                   +  " " + i);
               if (i == 20)
               {
                   // 创建、并启动第一条线程
                   new FirstThread().start();
                   // 创建、并启动第二条线程
                   new FirstThread().start();
               }
           }
       }
   }
   

2. 实现Runnable接口 （无返回结果）

3. 实现Callable接口

4. 线程池

7.1 Callable 接口

Callable 接口的特点如下(重点)

• 为了实现 Runnable，需要实现不返回任何内容的 run（）方法，而对于Callable，需要实现在完成时返回结果的 call（）方法。
• call（）方法可以引发异常，而 run（）则不能。
• 为实现 Callable 而必须重写 call 方法
• 不能直接替换 runnable,因为 Thread 类的构造方法根本没有 Callable

package com.zh.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @Author: zhang hao
 * @Date: 2022/12/15 9:56
 * @Description: ToDo
 */

class MyThread implements Runnable{
    @Override
    public void run() {
    }
}

class MyThread2 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 200;
    }
}
public class Demo01 {
    public static void main(String[] args) {
        //启动Runnable线程
        new Thread(new MyThread()).start();
        //Callable线程不能使用 new Thread().start()方法启动，因为Thread()的构造方法中没有Callable类型的参数
        // new Thread(new MyThread2()).start();

        //FutureTask
        FutureTask<Integer> futureTask1 = new FutureTask<>(new MyThread2());

        // lambda表达式
        FutureTask<Integer> futureTask2 = new FutureTask<>(() -> {
            return 1024;
        });
    }
}

7.2 Future 接口

​ 当 call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。

​ 将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下:

**public boolean cancel（boolean mayInterrupt）：**用于停止任务。

如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true时才会中断任务。

• **public Object get（）抛出 InterruptedExceptionExecutionException：**用于获取任务的结果。

如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

• **public boolean isDone（）：**如果任务完成，则返回 true，否则返回 false可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

7.3 FutureTask

​ Java 库具有具体的 FutureTask 类型，该类型实现 Runnable 和 Future，并方便地将两种功能组合在一起。 可以通过为其构造函数提供 Callable 来创建FutureTask。然后，将 FutureTask 对象提供给 Thread 的构造函数以创建Thread 对象。因此，间接地使用 Callable 创建线程。

核心原理:(重点)

​ 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成

• 当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态
• 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法
• 一旦计算完成，就不能再重新开始或取消计算
• get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常
• get 只计算一次,因此 get 方法放到最后

8 JUC 三大辅助类

JUC 中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时 Lock 锁的频繁操作。这三种辅助类为：

• CountDownLatch: 减少计数

• CyclicBarrier: 循环栅栏

• Semaphore: 信号灯

8.1 减少计数 CountDownLatch

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。

• CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞

• 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)

• 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

package com.zh.demo;

import java.util.concurrent.CountDownLatch;

/**
 * @Author: zhang hao
 * @Date: 2022/12/15 10:30
 * @Description: ToDo
 */
public class CountDownLatchDemo {
    /**
     * 6 个同学陆续离开教室后值班同学才可以关门
     *
     * @param args
     */
    public static void main(String[] args) throws Exception {
        //定义一个数值为 6 的计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        //创建 6 个同学
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    if (Thread.currentThread().getName().equals("同学 6")) {
                        Thread.sleep(2000);
                    }
                    System.out.println(Thread.currentThread().getName() + "离开了");
                    //计数器减一,不会阻塞
                    countDownLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "同学" + i).start();
        }
        //主线程 await 休息
        System.out.println("主线程睡觉");
        countDownLatch.await();
        //全部离开后自动唤醒主线程
        System.out.println("全部离开了,现在的计数器为" + countDownLatch.getCount());
    }
}

8.2 循环栅栏 CyclicBarrier

​ CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作。

通俗来讲，就是线程数量达到CyclicBarrier 设置的值的时候，才会执行参数中的Runnable线程中的方法，由最后一个线程执行。

package com.zh.demo;

import java.util.concurrent.CyclicBarrier;

/**
 * @Author: zhang hao
 * @Date: 2022/12/15 10:34
 * @Description: ToDo
 */
public class CyclicBarrierDemo {
    //定义神龙召唤需要的龙珠总数
    private final static int NUMBER = 7;

    /**
     * 集齐 7 颗龙珠就可以召唤神龙
     *
     * @param args
     */
    public static void main(String[] args) {
        //定义循环栅栏
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, () -> {
            System.out.println("集齐" + NUMBER + "颗龙珠,现在召唤神龙!!!!!!!!!");
        });
        //定义 7 个线程分别去收集龙珠
        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                try {
                    if (Thread.currentThread().getName().equals("龙珠 3 号")) {
                        System.out.println("龙珠 3 号抢夺战开始,孙悟空开启超级赛亚人模式!");
                        Thread.sleep(5000);
                        System.out.println("龙珠 3 号抢夺战结束,孙悟空打赢了,拿到了龙珠 3 号!");
                    } else {
                        System.out.println(Thread.currentThread().getName() + "收集到了!!!!");
                    }
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "龙珠" + i + "号").start();
        }
    }
}

8.3 信号灯 Semaphore

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可。

package com.zh.demo;

import java.util.Random;
import java.util.concurrent.Semaphore;

/**
 * @Author: zhang hao
 * @Date: 2022/12/15 10:53
 * @Description: ToDo
 */
public class SemaphoreDemo {
    /**
     * 抢车位, 6 部汽车 1 个停车位
     * @param args
     */
    public static void main(String[] args) throws Exception{
        //定义 3 个停车位
        Semaphore semaphore = new Semaphore(3);
        //模拟 6 辆汽车停车
        for (int i = 1; i <= 6; i++) {
            Thread.sleep(100);
            //停车
            new Thread(() ->{
                try {
                    System.out.println(Thread.currentThread().getName() + "找车位 ing");
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "汽车停车成功!");
                    int time = new Random().nextInt(9999);
                    System.out.println("time = " + time);
                    Thread.sleep(time);
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName() + "溜了溜了");
                    semaphore.release();
                }
            }, "汽车" + i).start();
        }
    }
}

9 读写锁

9.1 乐观锁和悲观锁

==悲观锁：==不支持并发操作，只能一个一个进行操作，效率低。

==乐观锁：==乐观锁支持并发操作，在并发操作时，每个人都会取得当前数据库中的版本号，当提交时，会先和数据库中的版本号比对，如果想等，则修改数据，并修改数据库中的版本号，如果自己的版本号和数据库中的版本号不相同，则拒绝修改。

9.2 表锁和行锁

==表锁：==在操作数据库的某个表时，会对整张表进行上锁，别人无法操作此表。不会出现死锁。

==行锁：==在操作数据库的某张表时，对操作的某些行上锁 ，别人可以操作表中的其他行。可能会出现死锁。

9.3 读写锁

​ 现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。

​ 针对这种场景，JAVA 的并发包提供了读写锁 ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁。

1、线程进入读锁的前提条件：

• 没有其他线程的写锁
• 没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。

2、 线程进入写锁的前提条件：

• 没有其他线程的读锁
• 没有其他线程的写锁

9.4 ReentrantReadWriteLock

​ ReentrantReadWriteLock 实现了 ReadWriteLock 接口ReadWriteLock 接口定义了获取读锁和写锁的规范，具体需要实现类去实现；同时其还实现了 Serializable 接口，表示可以进行序列化，在源代码中可以看到 ReentrantReadWriteLock 实现了自己的序列化逻辑。

package com.zh.demo;

import lombok.Data;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author: zhang hao
 * @Date: 2022/12/15 14:20
 * @Description: ToDo
 */
@Data
class MyCache {
    //创建 map 集合
    private volatile Map<String,Object> map = new HashMap<>();
    //创建读写锁对象
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();
    //放数据
    public void put(String key,Object value) {
        //添加写锁
        rwLock.writeLock().lock();
        try {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入 "+key);
                    //暂停一会
                TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            map.put(key,value);
            System.out.println("线程"+Thread.currentThread().getName()+"写入了 "+value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放写锁
            rwLock.writeLock().unlock();
        }
    }
    //取数据
    public Object get(String key) {
        //添加读锁
        rwLock.readLock().lock();
        Object result = null;
        try {
            System.out.println("线程"+Thread.currentThread().getName()+"正在读取 "+key);
                    //暂停一会
                    TimeUnit.MICROSECONDS.sleep(300);
            result = map.get(key);
            System.out.println("线程"+Thread.currentThread().getName()+"读取了 "+key+" 的值为"+result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            rwLock.readLock().unlock();
        }
        return result;
    }
}

public class ReentrantReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.put(num+"",num);
            },String.valueOf(i)).start();
        }



        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                Object o = myCache.get(num + "");
            },String.valueOf(i)).start();
        }
    }
}

当把读写锁注释掉时，结果为：

线程1正在写入 1
线程3正在写入 3
线程2正在写入 2
线程5正在写入 5
线程4正在写入 4
线程1正在读取 1
线程2正在读取 2
线程3正在读取 3
线程5正在读取 5
线程4正在读取 4
线程4读取了 4 的值为null
线程5读取了 5 的值为null
线程2读取了 2 的值为null
线程1读取了 1 的值为null
线程3读取了 3 的值为null
线程1写入了 1
线程4写入了 4
线程2写入了 2
线程3写入了 3
线程5写入了 5

出现读取数据为空的原因是，写线程还没有将数据写入，读线程就开始读取，所以读取到的数据才是null；

当添加上读写锁之后，结果为：

线程1正在写入 1
线程1写入了 1
线程2正在写入 2
线程2写入了 2
线程3正在写入 3
线程3写入了 3
线程4正在写入 4
线程4写入了 4
线程5正在写入 5
线程5写入了 5
线程1正在读取 1
线程3正在读取 3
线程2正在读取 2
线程5正在读取 5
线程4正在读取 4
线程2读取了 2 的值为2
线程1读取了 1 的值为1
线程3读取了 3 的值为3
线程4读取了 4 的值为4
线程5读取了 5 的值为5

总结：

读写锁：一个资源可以被多个读线程访问，或者可以被一个写线程访问，但是不能同时存在读写线程，读写互斥，读读共享。

缺点：

• 造成锁饥饿，一直读，没有写操作，或者一直写，没有读操作
• 读的时候不能进行写操作，读完之后才能进行写操作。写的时候可以读（锁降级）

锁降级：

• 在线程持有读锁的情况下，该线程不能取得写锁(因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)。

• 在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）。

原因: 当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把获取读锁的线程“升级”为写锁；而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。

10 阻塞队列

10.1 BlockingQueue 简介

阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；

当队列是空的，从队列中获取元素的操作将会被阻塞。

当队列是满的，从队列中添加元素的操作将会被阻塞。

试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素。

试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增。

在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒。

为什么需要 BlockingQueue

好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue 都给你一手包办了。

10.2 阻塞队列的分类和核心方法介绍

1、ArrayBlockingQueue(常用)

​ 基于数组的阻塞队列实现，在 ArrayBlockingQueue 内部，维护了一个定长数组，以便缓存队列中的数据对象，这是一个常用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue 内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置。

队列生产者和消费者使用同一把锁，所以不是真正意义上的同步

一句话总结: 由数组结构组成的有界阻塞队列。

2、LinkedBlockingQueue(常用)

​ 基于链表的阻塞队列，同 ArrayListBlockingQueue 类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkedBlockingQueue 可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。而 LinkedBlockingQueue 之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

ArrayBlockingQueue 和 LinkedBlockingQueue 是两个最普通也是最常用的阻塞队列，一般情况下，在处理多线程间的生产者消费者问题，使用这两个类足以。

一句话总结: 由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列。

3、DelayQueue

DelayQueue 中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue 是一个没有大小限制的队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。

一句话总结: 使用优先级队列实现的延迟无界阻塞队列。

BlockingQueue 核心方法

BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

11 ThreadPool 线程池

​ 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

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

线程池的特点（好处）

• 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
• 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
• 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
• Java中的线程池是通过 Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor 这几个类

11.1 常用线程池

11.1.1 newFixedThreadPool(常用)

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

特征：

• 线程池中的线程处于一定的量，可以很好的控制线程的并发量

• 线程可以重复被使用，在显示关闭之前，都将一直存在

• 超出一定量的线程被提交时候需在队列中等待

/**
* 固定长度线程池
* @return
*/
public static ExecutorService newFixedThreadPool(){
/**
* corePoolSize 线程池的核心线程数
* maximumPoolSize 能容纳的最大线程数
* keepAliveTime 空闲线程存活时间
* unit 存活的时间单位
* workQueue 存放提交但未执行任务的队列
* threadFactory 创建线程的工厂类:可以省略
* handler 等待队列满后的拒绝策略:可以省略
*/
return new ThreadPoolExecutor(10,
	10,
	0L,
	TimeUnit.SECONDS,
	new LinkedBlockingQueue<>(),
	Executors.defaultThreadFactory(),
	new ThreadPoolExecutor.AbortPolicy());
}

场景: 适用于可以预测线程数量的业务中，或者服务器负载较重，对线程数有严格限制的场景。

11.1.2 newCachedThreadPool(常用)

作用：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程.

特点:

• 线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）

• 线程池中的线程可进行缓存重复利用和回收（回收默认时间为 1 分钟）

• 当线程池中，没有可用线程，会重新创建一个线程

ExecutorService executorService = Executors.newCachedThreadPool();

11.1.3 newSingleThreadExecutor(常用)

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

特征： 线程池中最多执行 1 个线程，之后提交的线程活动将会排在队列中以此执行。

ExecutorService executorService = Executors.newSingleThreadExecutor();

创建的线程池底层都是通过 new ThreadPoolExecutor（），传入不同的构造参数来实现的

11.2 线程池的参数（重点）

• corePoolSize 线程池的核心线程数（常驻线程数量）

• maximumPoolSize 能容纳的最大线程数

• keepAliveTime 空闲线程存活时间

• unit 存活的时间单位

• workQueue 存放提交但未执行任务的队列

• threadFactory 创建线程的工厂类

• handler 等待队列满后的拒绝策略

11.3 线程的拒绝策略（重点）

CallerRunsPolicy: 调用者运行，当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大

AbortPolicy: 丢弃任务，并抛出拒绝执行(默认)RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。

DiscardPolicy: 直接丢弃，其他啥都没有

DiscardOldestPolicy: 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

注意！！！！

在实际使用中，要使用自定义线程池

11.4 自定义线程池

ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                10,
                20l,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

12 异步回调CompletableFuture

同步和异步的区别

同步是指等待线程执行完某个任务后，再去执行其他的任务。

=创建的线程池底层都是通过 new ThreadPoolExecutor（），传入不同的构造参数来实现的==

11.2 线程池的参数（重点）

• corePoolSize 线程池的核心线程数（常驻线程数量）

• maximumPoolSize 能容纳的最大线程数

• keepAliveTime 空闲线程存活时间

• unit 存活的时间单位

• workQueue 存放提交但未执行任务的队列

• threadFactory 创建线程的工厂类

• handler 等待队列满后的拒绝策略

11.3 线程的拒绝策略（重点）

CallerRunsPolicy: 调用者运行，当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大

AbortPolicy: 丢弃任务，并抛出拒绝执行(默认)RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。

DiscardPolicy: 直接丢弃，其他啥都没有

DiscardOldestPolicy: 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

注意！！！！

在实际使用中，要使用自定义线程池

[外链图片转存中…(img-nM1FxwFe-1680600554197)]

11.4 自定义线程池

ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                10,
                20l,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

12 异步回调CompletableFuture

同步和异步的区别

同步是指等待线程执行完某个任务后，再去执行其他的任务。

异步回调是指不需要等待线程执行完当前任务，等需要使用结果的的时候，再调用其中的方法获取结果。