JAVA中多线程的基本用法

---

一、基本概念

（一）进程控制块PCB

 进程可以理解为一个正在运行的程序，进程由PCB、程序段、数据段组成。进程控制块PCB是一个结构体，存储了进程的相关属性；程序段包含程序的代码（指令序列）；数据段包含了进程运行过程中产生的各种数据。

 操作系统首先描述一个进程，明确出进程上面的一些相关属性，再组织若干个进程，使用数据结构把很多描述信息的进程放到一起，方便进行增删改查。描述进程用到的结构体被称为 PCB（Process Control Block）即进程控制块。PCB中的描述信息包含了进程的基本信息、给进程分配的资源、进程的运行情况等。

 所谓的创建进程就是先创建出 PCB，然后把 PCB 加到双向链表中；销毁进程就是找到链表上的PCB，并且从链表上删除；查看任务管理器就是 遍历链表。PCB是进程存在的唯一标志，程序开始运行前，需要创建对应的进程，即创建相应的PCB，PCB当中包含一些属性，包括进程id、内存指针、文件描述符表等

• 进程 id ：相当于进程的身份标识，系统中每个进程有唯一的id
• 内存指针：指明了当前该进程要执行的代码/指令在内存的哪个位置，以及进程执行过程中依赖的数据位置。每运行一个exe文件，此时操作系统就会把这个exe加载到内存中变成进程，进程不仅要执行一些编译器生成的二进制指令，还要处理对应的数据。
• 文件描述符： 进程每次打开一个文件，就会在文件描述表上多增加一项，文件描述表的下标就是文件描述符，一个程序只要启动，不管代码中是否包含打开/操作文件的代码，都会默认打开三个文件（标准输入System.in、标准输出System.out、标准错误System.err）。文件描述符可以看成是一个数组，里面的每个元素是一个结构体，对应一个文件的相关信息。

（二）并行和并发

• 并行：微观上两个CPU核心，同时执行两个任务的代码

• 并发：微观上一个CPU核心先执行一会任务1，在执行一会任务2，在执行一会任务3…只要切换的足够快，宏观上看起来，就好像一个CPU在执行多个任务一样

• 并行和并发只能在微观上进行区分，在宏观上来看不能进行区分

• 并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在

（三）进程调度

 进程的调度就是在考虑CPU资源如何分配给各个进程

 操作系统对CPU的资源分配，采用的是时间模式：不同的进程在不同的时间段去使用CPU资源。操作系统对内存的资源分配，采用的是空间模式：不同进程使用内存中的不同区域，互相之间不会干扰。
不同的进程需要访问内存空间，如果所有进程都访问同一个内存空间，那么如果某个进程出现问题把内存中的数据写错了，就可能会引起其他进程的崩溃。这时通过设置虚拟地址空间来实现 " 进程的独立性"

• 两个进程之间隔离开不能直接进行交互，但是在实际工作中，进程之间还是需要互相交互的，此时操作系统就设置了一个 “公共空间” ，进程A把数据放到公共空间上，进程B再取走，从而实现了进程之间的通信
• 操作系统提供的 “公共空间” 有多种，包含存储空间的大小、存取速度的快慢等多种。现在用到的最主要的两种进程间的通讯方式包括：文件操作和网络操作

1.进程的状态

 运行状态：进程已占用CPU，并在CPU上执行
 就绪状态：进程已具备运行条件，随时可以上CPU去执行
 阻塞状态：进程暂时不可以上CPU执行

2.优先级

 CPU先给谁分配时间，后给谁分配时间，即进程获取CPU资源的先后顺序

3.记账信息

 记账信息统计了每个进程都分别被执行了多久，又分别执行了那些命令，分别排队多久

4.上下文

 上下文表示了上次进程被调度出CPU时，当时程序的运行状态，等到下次进程上CPU时就可以恢复之前的状态，再继续往下执行

（四）进程和线程

1.概述

• 进程就是一个跑起来的程序，进程包含线程
• 频繁的创建/销毁/调度进程的成本比较高，若考虑使用进程池，池子里面闲置的进程不使用时也在消耗系统资源，因此考虑使用线程的方式来降低成本，
• 线程比进程更轻量，每个进程或者线程都能够执行一个任务，也都能够并发编程，但是线程的创建/销毁/调度成本比进程要低很多
• 在Linux上，线程也被称为轻量级进程（LWP，Light Weight Process）

2.线程为什么比进程更轻量

• 进程的重量在于资源的申请和释放，线程是包含在进程中的，一个进程中的多个线程共用同一份内存+文件

• 只是创建进程的第一个线程的时候需要分配资源，成本相对较高，但后续这个进程中再创建其他线城市就不必在分配资源了，成本较低

• 同时，如果线程多了，这些线程可能要竞争同一个资源，这样整体的速度就受到了限制

3.进程和线程的区别和联系

• 进程包含线程，一个进程可以有一个线程，也可以有多个线程
• 进程和线程都是为了处理并发变成这样的场景。但是频繁的创建/释放/调度进程的效率比较低，而线程更加轻量，效率更高
• 进程是系统分配资源（内存、文件等资源）的基本单位，线程是系统调度执行的基本单位（CPU）。操作系统创建进程，要给进程分配系统资源，进程是操作系统分配资源的基本单位’操作系统创建的线程，是要在CPU上调度执行，线程是操作系统调度执行的基本单位
• 进程具有独立性，每个进程都有各自独立的虚拟地址空间，不会影响到其他进程
  同一个进程中有多个线程时，多个线程共用一个内存空间，一个线程出现bug可能影响到其他线程，甚至导致整个程序崩溃

二、多线程

（一）线程的创建

 操作系统提供了一组关于线程的API，JAVA对这组API进一步封装了一下，就成了Thread类。在JAVA标准库中，一个Thread类用来表示或操作线程，Thread类可以理解为JAVA标准库提供的API，创建好的Thread实例，其实和操作系统中的线程是一一对应的关系

1.写法一，创建子类继承Thread

• run方法内部描述了线程内部要执行的代码，run方法中的逻辑，是在新创建出来的线程中执行的代码，

• t.start()这里调用start方法，才是真正在系统中创建了线程，并开始run操作，调用star之前系统中是没有创建出线程的

class MyThread extends Thread{@Overridepublic void run(){System.out.println("hello world!");}
}
public class Demo {public static void main(String[] args) {Thread t = new MyThread();t.start();}
}

2.写法二，创建一个类，实现Runnable接口，再创建Runnable实例传给Thread实例。

• 通过Runnable来描述任务的内容，进一步的再把描述好的任务交给Thread实例

class MyRunnable implements Runnable{@Overridepublic void run() {System.out.println("MyRunnable");}
}
public class Demo3 {public static void main(String[] args) {Thread t = new Thread(new MyRunnable());t.start();}
}

3.写法三/四，使用了匿名内部类，继承自Thread类，同时重写run方法，再new出这个匿名内部类的实例

• 通常认为Runnable的写法会更好些，能够做到让线程和线程执行的任务更好的解耦，因为Runnable单纯只描述了一个任务，但任务通过进程来执行，还是其他的进程池，或者协程来执行，与Runnable本身相关性不大

    public static void main(String[] args) {Thread t = new Thread(){@Overridepublic void run() {System.out.println("inner Thread");}};t.start();}

    public static void main(String[] args) {Thread t = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("inner Thread");}});t.start();}

4.写法五，使用lambda表达式，本质上是用lambda代替了Runnable

    public static void main(String[] args) {Thread t = new Thread(() ->{System.out.println("hello");});t.start();}

 多线程能够提高任务完成的效率，尤其是需要同时处理的数据量较大时，例如下面的例子，给a和b两个变量分别自增到count数量级，使用线程处理的时间效率相较于顺序执行要优很多,
 运行得到：顺序执行时间为634ms，多线程运行时间为380ms，相差一倍左右

  注意创建线程代码中，main和t1、t2并发执行，此时t1、t2还没有执行完就开始记录时间是不准确的，应该让main线程等待t1、t2执行完再来记录，使用join的效果就是等待线程结束， t1.join()让main线程等待t1结束，t2.join()让main线程等待t2结束

public class Demo {private static final long count = 10_0000_0000;public static void serial() {long begin = System.currentTimeMillis();long a = 0;for(long i = 0;i < count; i++){a++;}long b = 0;for(long j = 0;j < count; j++){b++;}long end = System.currentTimeMillis();System.out.println("消耗时间："+(end-begin)+"ms");}public static void concurrency() throws InterruptedException {long begin = System.currentTimeMillis();Thread t1 = new Thread(() ->{long a = 0;for(long i = 0;i < count; i++){a++;}});t1.start();Thread t2 = new Thread(() ->{long a = 0;for(long i = 0;i < count; i++){a++;}});t2.start();t1.join();t2.join();long end = System.currentTimeMillis();System.out.println("消耗时间："+(end-begin)+"ms");}public static void main(String[] args) throws InterruptedException {serial();concurrency();}
}

（二）Thread类的属性和方法

1.构造方法

给线程起名字方便再调试的时候对线程进程区分，可以借助JDK中的jconsole观察线程的名字

方法	说明
public Thread()	创建线程对象
public Thread(Runnable target)	使用Runnable对象创建线程对象
public Thread(String name)	创建线程对象，并命名
public Thread(Runnable target, String name)	使用Runnable对象创建线程对象，并命名

2.属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

• 是否后台线程isDaemon()：JVM会在一个进程的所有非后台线程结束之后才会结束执行。如果线程是后台线程，那么就不影响进程的推出，如果是前台线程，就会影响到进程的进出，例如上面例子中创建的t1、t2线程默认为前台线程，当main方法执行完毕，两个进程也不能退出，需要等t1、t2线程执行完毕后整个进程才能退出；若为后台线程，那么main方法执行完毕后整个进程直接退出，t1、t2线程强行终止
• 是否存活 isAlive()：指操作系统中对应的线程是否正在运行，Thread t 只是创建了一个对象，创建 t 对象后调用t.start()才是创建了一个线程，因此t对象的生命周期和内核中线程对应的生命周期并不完全一致，run方法执行完毕后系统中的线程就销毁了，但是t对象可能还存在。start()开始之后，run()结束之前的时间内isAlive()判定为true

3.启动线程start()

• start()是真正决定线程是否创建的方法，而run()方法仅是一个普通的方法，仅调用run方法并不会创建新的线程。
  例如下面的代码，没有start()创建线程，程序中依然只有main这一个线程，循环五次hello thread后顺序执行

public class Demo {public static void main(String[] args) {Thread t = new Thread(()->{while (true){System.out.println("hello thread");try{Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.run();while(true){System.out.println("hello main");try{Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

4.线程中断

 中断线程即让线程对应的run方法执行完毕，特殊的main线程来说，mian方法执行完毕，线程即结束，有以下两种方式进行线程中断

 1. 手动设置一个标志位来控制线程是否要执行。此处因为多线程共用一个虚拟地址空间，因此main线程修改的 isQuit和 t 线程判定的 isQuit 是同一个值

public class Demo {private static boolean isQuit = false;public static void main(String[] args) {Thread t = new Thread(()->{while (!isQuit){System.out.println("hello thread");try{Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}isQuit = true;System.out.println("终止t线程");}
}

 2. 使用Thread内置的标志位来进行判定，使用Thread.interrupted();设置的一个静态的方法，或者使用Thread.currentThread().isInterrupted() 实例的方法，currentThread能够获取到当前线程的实例

• 一般来说更推荐使用 isInterrupted方法，因为Thread.interrupted()方法判定的标志位是Thread的一个static静态成员，这样一个程序中只有一个标志位；而一个代码中的线程可能有多个，Thread.currentThread().isInterrupted()这个方法判断的标志位是Thread的普通成员，每个示例都有自己的标志位

• 对于调用这个t.interrupt();方法，需要注意 如果t线程处在就绪状态，就设置线程的标志位为true；如果t线程处在阻塞状态（sleep状态），就会触发一个InterruptedException异常

• 对于下面的代码来说，运行后发现interrupt方法会在线程阻塞态时调用，此时就会让sleep触发一个异常从而导致线程从阻塞状态被唤醒，一旦触发异常之后，就进入了catch语句，从而打印了一个日志，可以在打印后立刻break，来避免这种情况

public class Demo {public static void main(String[] args) {Thread t = new Thread(()->{while(!Thread.currentThread().isInterrupted()){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();break;//添加的操作}}});t.start();try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}t.interrupt();}
}

5.线程等待

一般来说，线程之间的调度是按照调度器来安排的，这个过程是无序且随机的，当我们需要控制线程之间的顺序时，需要使用到join方法，对应的线程会进入阻塞等待，直到对应的线程执行完毕（对应线程的 run 方法执行完）

• 在下面这个例子中，main线程中调用 t.join，那么main线程就会进入阻塞状态，直到 t 线程执行完毕，一定程度上干预了两个线程的执行顺序

• join操作默认是死等，因此提供了另一个版本，设置最多join最多等待过长时间，即在join内部设置最大时间，当超过这个时间之后，这样join就直接返回，不再继续等待

public class Demo {public static void main(String[] args) {Thread t = new Thread(()->{for(int i=0;i<5;i++){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();break;}}});try {t.join(10000);} catch (InterruptedException e) {e.printStackTrace();}}
}

6.获取当前线程的引用

 Thread.currentThread()能够获取到当前线程的引用，哪个线程调用的currentThread，就获取到哪个线程的实例
下面这个代码中通过继承Thread的当时来创建线程，此时在run方法中拿到的就是Thread的实例

public class Demo11 {public static void main(String[] args) {Thread t = new Thread(){@Overridepublic void run(){//System.out.println(Thread.currentThread().getName());System.out.println(this.getName());}};t.start();//在main线程中调用的，因此拿到的就是main这个线程实例System.out.println(Thread.currentThread().getName());}
}

 如果是实现了Runnable接口的线程，由于Runnable是一个单独的任务没有name属性，此时不能通过this获得引用，只能通过Thread.currentThread().getName()进行获取

public class Demo {public static void main(String[] args) {Thread t = new Thread(new Runnable() {@Overridepublic void run() {System.out.println(this.getName());//errorSystem.out.println(Thread.currentThread().getName());}});t.start();}
}

7.线程休眠

 当一个进程有多个线程的时候，此时每个线程都有一个PCB，此时一个进程就对应一组PCB了。PCB上的一个字段 tgroupId 这个 id 相当于是进程的 id,同一个进程中的若干个线程的tgroupId 是相同的

• 针对Linux系统而言，当前链表中的PCB都有各自的状态(就绪/阻塞)，当其中某个线程调用了sleep方法，这个PCB就会进入到阻塞队列，，当操作系统调度线程的时候，就只是从就绪队列中挑选合适的PCB到CPU上运行，阻塞队列中的PCB只能等到睡眠时间结束后，操作系统才会把其从阻塞队列调回到就绪队列

三、线程状态

（一）线程的基本状态

通过t.getState()方法获取对应线程的状态

• NEW状态：安排了工作还未开始行动，即Thread对象创建了但是还没有调用start()方法
• TERMINATED状态：工作完成了，操作系统中的线程已经执行完毕销毁了，但是Thread对象还在，从而获取到的状态
• RUNNABLE状态：可工作的，又可以分为正在工作中和即将开始工作的，也是就绪状态，处于该状态的线程在就绪队列中，随时可以被调用到CPU上执行。如果代码中没有进行sleep或其他可能导致阻塞的操作，线程即在RUNNABLE状态
• TIMED_WAITING状态：代码中调用了 sleep 或 join 等操作就会进入到该状态，即当前线程在一定时间内是阻塞的状态，一定时间后状态解除
• BLOCKED状态：当前线程在等待锁导致了阻塞
• WAITING状态：当前线程在等待唤醒导致了阻塞

（二）线程的状态转移

（三）线程安全

1.基本介绍

 线程的安全主要指的是由于操作系统进行线程调度的时候是否会带来问题

 一个经典的线程不安全的例子是两个线程分别自增对应的数字，如下所示，两个线程总共相加应该为100000的情况，但最终得到的结果总在50000和100000之间

class Counter{public int count;public void increase(){count++;}
}
public class Demo13 {private static Counter counter = new Counter();private static int count2 = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for(int i = 0;i<50000;i++){counter.increase();count2++;}});Thread t2 = new Thread(()->{for(int i = 0;i<50000;i++){counter.increase();count2++;}});t1.start();t2.start();//在t1、t2执行完之后再打印count的结果//在main中打印两个线程执行的结果t1.join();t2.join();System.out.println(counter.count);System.out.println(count2);}
}

 count在进行自增时候，首先要内存中的 count 值加载到CPU寄存器中，在寄存器中的值加一，最后把寄存器的值写回到内存的count中。因此在“抢占式执行”的时候，两个操作导致本来应该自增两次，结果只自增了一次

 可以通过在自增之前加锁，自增后解锁。加锁后并发程度就降低了，此时的数据操作更具有安全性，但也会导致执行速度变慢。加锁最常使用synchronized，给方法直接加synchronized关键字，此时进入方法会自动加锁，离开方法自动解锁。线程加锁成功后，其他线程尝试加锁会触发阻塞等待，此时的线程就处在BLOCKED状态，阻塞会一致持续到占用锁的线程把锁释放位置。

class Counter{public int count;synchronized public void increase(){count++;}
}

2.产生线程不安全的原因

1. 线程抢占式执行，线程之间的调度随机
2. 多个线程对同一个变量进行修改，针对两个变量的情况不会产生问题，或多个线程针对同一个变量进行读操作时也不会产生问题
3. 针对变量的操作不是原子性的，例如针对读取变量的值，该操作只对应一条机器语言，因此可以认为是原子的，对非原子的操作可以通过加锁把多个指令打包成一个原子的
4. 内存的可见性也会影响到线程的安全。即一个t1线程在循环读，一个t2线程进行写操作，由于 t1 线程读取内存的效率比读取寄存器的效率要低很多(3-4个数量级)，于是编译器自我优化，此时t1就直接从寄存器中读取数据，t2 再进行修改的后，t1 就会读取到错误的数据，如下例所示，线程 t 没有感知到数据的变化

import java.util.Scanner;public class Demo {private static int isQuit = 0;public static void main(String[] args) {Thread t =new Thread(()->{while(isQuit == 0){//循环读取isQuit的值}System.out.println("循环结束！t 线程退出！");});t.start();Scanner scanner = new Scanner(System.in);System.out.println("请输入一个isQuit值：");//输入修改后t线程并没有执行结束isQuit = scanner.nextInt();System.out.println("main线程执行完毕");}
}

 针对内存的可见性导致的线程不安全，可以使用下面的方法进行修改

• 使用synchronized关键字： synchronized以保证指令的原子性，同时也可以保证内存的可见性，相当于手动禁用了编译器的优化
• 使用volatile关键字，和原子性无关但能保证内存可见性，会禁止编译器进行优化，此时编译器每次执行判定会重新读取内存的值，如下所示

public class Demo {private static volatile int isQuit = 0;public static void main(String[] args) {...}
}

如果在循环中加入sleep，可以发现编译器优化消失了，即也不存在内存可见性问题

public class Demo {private static int isQuit = 0;public static void main(String[] args) {Thread t =new Thread(()->{while(isQuit == 0){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("循环结束！t 线程退出！");});...}
}

5. 指令重排序，也是编译器优化中的一种操作，即编译器在不改变逻辑的前提下，改变代码执行的先后顺序，需要使用synchronized关键字，同时保证原子性、内存可见性、禁止指令重排序

3.死锁

（1）死锁产生的情况

• 一个线程，同时加多个锁，相互等待
• 两个线程，两个锁，互相等待
• N个线程M个锁（哲学家就餐问题）

（2）死锁的四个必要条件

• 互斥使用：进程之间互斥使用资源，任意时刻一个资源只能给一个进程使用，即一个锁被一个线程占用后其他线程占用不了
• 不可抢占：进程所获得的资源在未使用完毕之前，不被其他进程强行剥夺，而只能由获得该资源的进程资源释放，即一个锁被线程占用后，其他线程只能等待其释放，不能进行抢占
• 请求和保持：进程在申请新资源时，继续占用已分配到的资源，即线程占据了多把锁后，除非显示的释放锁，否则会一直持有
• 环路等待：每个线程都在等待下一个线程持有的资源，从而形成一个锁

4.synchronized关键字（监视器锁 monitor lock）

（1）synchronized关键字的特性

• synchronized会起到互斥的效果

• synchronized可以刷新内存，保证内存的可见性。首先获得互斥锁，从主内存中拷贝变量的副本到工作的内存，执行代码后将更改后的共享变量的值更新到主内存，最后释放互斥锁

• synchronized具有可重入的特性

 对于连续加锁的操作来说，一般来说，外层锁需要等到整个方法执行完毕后才能释放，而内层锁又由于外层锁被占用无法进行加锁，从而导致死锁情况。但对于synchronized来说这种连续加锁的操作并不会导致死锁。

class Counter{public int count;synchronized public void increase(){synchronized(this){count++;}}
}

 synchronized会在加锁时记录加锁的次数，后续在解锁的时候再依次减少，解锁次数减到0的时候完全解锁，这就是可重入锁。这种锁降低了使用成本，相应提高了开发效率，但是加减计数操作降低了运行效率

（2）synchronized的使用方法

• 1.修饰普通的方法：在使用synchronized的时候，本质上是在对某个“对象”进行加锁，此时的锁对象就是this。一个new出来的实例，包含了程序员自身设置的属性，还包括一个“对象头”，包含对象的一些元数据，加锁操作就是在对象头里设置了标志位，加锁对象在this的对象头的标志位

class Counter{public int count;synchronized public void increase(){count++;}
}

• 2.修饰一个代码块：需要显示的指定那个对象加锁，在JAVA中，任意对象都可以作为一个锁对象，这也是JAVA语言的一个特色

class Counter{public int count;public void increase(){synchronized(this){count++; }}
}

• 3.修饰一个静态方法：因为静态方法本质上来说是一个类方法，因此相当于给当前的类对象加锁

class Counter{public int count;public static void func(){synchronized(Counter.class){}}
}

class Counter{public int count;synchronized public static void func(){}
}

5.JAVA标准库中的线程安全类

• 线程不安全类：ArrayList、LinkedList、HashMap、TreeMap、HashSet、TreeSet、StringBuilder

• 线程安全类：vector、HashTable、ConcurrentHashMap、StringBuffer（前四种都带有synchronized修饰）、String（String是不可变对象）

6.volatile 关键字

 volatile 关键字能够保证内存可见性，但不能保证原子性，因此 volatile 只能处理一个线程读，一个线程写之间的问题

• JMM（Java Memory Model，Java内存模型）将硬件结构在Java中用专门的术语封装了一遍，CPU抽象成工作内存（work memory），内存抽象成主内存（main memory）

• 频繁读取数据时，CPU从内存中读取的数据速度太慢，因此要把这样的数据放到寄存器里，通过寄存器进行读取，但寄存器空间紧张，而缓存cache比寄存器大，比内存小，速度比寄存器慢，比内存快，因此数据会放到缓存中进行读取

• 对于一般的三级缓存来说，存储空间：CPU < L1 < L2 < L3 < 内存；速度：CPU > L1> L2 > L3 > 内存；成本：CPU > L1> L2 > L3 > 内存。最常用的数据放到CPU的寄存器里

• 当写一个 volatile 变量时，JMM 会把该线程在本地内存中的变量强制刷新到主内存中去

7.wait 和 notify 方法

 wait 和 notify 都是 Object 对象的方法，都针对同一个对象来操作，都需要搭配 synchronized 来使用。调用wait方法会首先使线程进入到阻塞状态，阻塞到其他线程通过notify进行通知

• wait 内部首先会把线程放入到等待队列中，然后释放当前的锁，最后等待其他线程的通知，收到通知后重新获取锁，并继续往下执行
• notify 也需要在 synchronized 下进行使用，通过notify来通知可能等待该对象的对象锁的其他线程，并发出notify通知，并使他们重新获取该对象的对象锁
• 可以通过wait 和 notify来协调多个线程之间执行的先后顺序
• notifyAll会全部唤醒所有的等待线程，notify则是随机唤醒一个等待线程
• notifyAll在唤醒所有等待线程的时候，wait会重新获取锁，同样也会发生竞争

public class Demo {private static Object locker = new Object();public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{synchronized (locker){System.out.println("wait 前");try {locker.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("wait 后");}});t1.start();Thread.sleep(3000);Thread t2 = new Thread(()->{synchronized (locker){System.out.println("notify 前");locker.notify();System.out.println("notify 后");}});t2.start();}
}