目录
一、volatile关键字1.1 内存可见性1.2 volatile解决内存可见性问题 二、wait和notify2.1 wait2.2 notify2.3 使用例子2.3.1 例子12.3.2 例子二
一、volatile关键字
volatile可以保证内存可见性，只能修饰变量。
1.1 内存可见性
在前面介绍线程不安全原因时介绍到了，在Java中有JMM (Java Memory Model)（Java内存模型）来介绍。
计算机运行代码/程序的时候，访问数据常常要从内存中访问（定义变量时变量就储存在内存中），
然而CPU从内存中读取数据相比于从寄存器中读取数据要慢上很多（几千上万倍），CPU在进行读/写内存的时候速度就会降低。
为了解决这种问题，提高效率，编译器就可能会对代码优化，把一些本来要读取内存的操作，优化为读取寄存器，减少读取内存的次数。这就会导致内存可见性问题。
例如以下代码输入一个不为0的数，本应该打印“threade1结束”，但是并没有。
import java.util.Scanner;public class Demo { public static int isQuite = 0; public static void main(String[] args) { Thread thread1 = new Thread(() -> { while(isQuite == 0) { } System.out.println("threade1结束"); }) ; Thread thread2 = new Thread(() -> { Scanner scanner = new Scanner(System.in); isQuite = scanner.nextInt(); }); thread1.start(); thread2.start(); }}以上述代码讲解：
在thread1中while先读取isQuite的值，在进行比较，然而编译器/JVM发现多次得到的isQuite都是0，这个线程也没有修改isQuite操作，然后编译器/JVM就大胆优化只进行第一次的读取isQuite操作，后续直接从寄存器里面读取。
其实编译器/JVM进行优化是不可控的，如果在while循环里面加上sleep，sleep的时间够久了，已经够进行读取操作，可能就不会优化了。
1.2 volatile解决内存可见性问题
如上诉代码，我们直接在isQuite加上volatile修饰，就告诉编译器/JVM不要进行优化，就可以解决问题。
volatile可以解决内存可见性问题，解决不了原子性问题。
import java.util.Scanner;public class Demo {volatile public static int isQuite = 0; public static void main(String[] args) { Thread thread1 = new Thread(() -> { while(isQuite == 0) { } System.out.println("threade1结束"); }) ; Thread thread2 = new Thread(() -> { Scanner scanner = new Scanner(System.in); isQuite = scanner.nextInt(); }); thread1.start(); thread2.start(); }}二、wait和notify
在多线程中一个重要的机制是协调各个线程之间的调度顺序，在操作系统是随机调度。
在前面我们介绍了等待一个线程使用join，但是使用join就要等到调用线程结束。而wait不用，wait和notify就是专门协调线程执行逻辑的顺序的。
wait和notify是Object类的成员方法，也就是每一个对象都有。
wait：等待，让指定线程进入阻塞状态。
notify：通知，唤醒对应进入阻塞状态的线程。
2.1 wait
线程饿死/饿死：线程恶死就是指当多个线程竞争一把锁的时候，当线程1拿到了锁，释放锁之后，又由于操作系统的随机调度再次多次让线程1拿到锁，其他线程多次没拿到锁处于阻塞状态，没分配到CPU资源。就相当于鸟妈妈给小鸟喂食，多次喂食都是给一只小鸟，那么其它小鸟就处于饥饿/饿死状态。
我们可以使用wait来避免线程饥饿，当线程拿到锁发现时机不成熟的时候，就可以使用wait让线程进入阻塞状态，等待唤醒。
语法：
synchronized(锁对象) {锁对象.wait();}注意事项：
wait()必须搭配synchronized使用：因为wait()的机制就是先释放锁对象的锁，然后等待唤醒在加锁继续执行剩下逻辑。如果对象没有处于加锁状态，就会抛出IllegalMonitorStateException（非法锁状态异常）。wait会抛InterruptedException
wait也有含时间版本，超过时间自动唤醒。
2.2 notify
notify就是唤醒wait。
语法：
synchronized(锁对象) {锁对象.notify();}注意事项：
notify必须在wait后面执行才能唤醒wait；notify和要唤醒的wait要是同一个锁对象；如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”)。当有多个线程等待时，可以使用notifyAll()来唤醒所有，但是实际上还是一个一个唤醒。2.3 使用例子
2.3.1 例子1
题目：使用多线程来打印ABC,一个线程一个字母，打印10个ABC。
解析：线程1唤醒线程2，线程2唤醒线程3，线程3唤醒线程1。主线程中保证先唤醒一下线程1即可。
代码：
public class Demo { public static void main(String[] args) throws InterruptedException { Object block1 = new Object(); Object block2 = new Object(); Object block3 = new Object(); Thread thread1 = new Thread(() -> { try { for (int i = 0; i < 10; i++) { synchronized (block1) { block1.wait(); } System.out.print("A"); synchronized (block2) { block2.notify(); } } }catch (InterruptedException e) { e.printStackTrace(); } }); Thread thread2 = new Thread(() -> { try { for (int i = 0; i < 10; i++) { synchronized (block2) { block2.wait(); } System.out.print("B"); synchronized (block3) { block3.notify(); } } }catch (InterruptedException e) { e.printStackTrace(); } }); Thread thread3 = new Thread(() -> { try { for (int i = 0; i < 10; i++) { synchronized (block3) { block3.wait(); } System.out.print("C"+" "); synchronized (block1) { block1.notify(); } } }catch (InterruptedException e) { e.printStackTrace(); } }); thread1.start(); thread2.start(); thread3.start(); Thread.sleep(1000); synchronized (block1) { block1.notify(); } }}2.3.2 例子二
题目：有三个线程，线程名称分别为：a，b，c。
每个线程打印自己的名称。
需要让他们同时启动，并按 c，b，a的顺序打印。
代码：
public class Demo { public static void main(String[] args) throws InterruptedException { Object block1 = new Object(); Object block2 = new Object(); Object block3 = new Object(); Thread a = new Thread( () -> { Thread.currentThread().setName("a"); try{ synchronized (block1) { block1.wait(); } System.out.println(Thread.currentThread().getName()); } catch (InterruptedException e) { e.printStackTrace(); } }); Thread b = new Thread(() -> { Thread.currentThread().setName("b"); try{ synchronized (block2) { block2.wait(); } System.out.print(Thread.currentThread().getName()+","); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (block1) { block1.notify(); } }); Thread c = new Thread(() -> { Thread.currentThread().setName("c"); try{ synchronized (block3) { block3.wait(); } System.out.print(Thread.currentThread().getName()+","); synchronized (block2) { block2.notify(); } } catch (InterruptedException e) { e.printStackTrace(); } }); a.start(); b.start(); c.start(); Thread.sleep(1000); synchronized (block3) { block3.notify(); } }}