一、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();}}
}