JAVAEE线程安全问题及解决方案（四）

一.wait(等待)与notify(通知)

1.wait()/notify()的作用

线程在操作系统上的调度是随机的。

多个线程，我们需要控制线程之间执行某个逻辑的先后顺序，就可以让后执行的逻辑执行wait，先执行的线程完成某些逻辑后通过notify唤醒对应的wait。

另外，通过wait/notify也是为了解决“线程饿死”问题。

2.案例解析

以下通过ATM机取钱为例，解释wait()和notify()

假设滑稽老哥一天去ATM取钱，发现ATM里没钱了（现实里ATM里的钱不是每天自动刷新的，是每天运钞车送过来的），但滑稽老哥一定要完成取钱任务，于是他在ATM里进进出出，后面的滑稽老铁就一直看着他进进出出，无法进去存钱或干别的操作。

以上场景，在现实世界中是及其抽象的，因为正常人早上去干前面的滑稽老哥了，但把滑稽们全部换成线程，线程是通过代码控制的，是没能力“干”它的。后面的线程长期得不到实现，于是就发生了“线程饿死”。

针对上述问题，我们可以通过wait/notify来解决。

首先，让1号滑稽老哥进入ATM时（抽象为线程上锁），判断能否执行“取钱”操作，如果能执行，就正常执行。

如果不能执行，就需要主动释放锁，并且“阻塞等待”（调用“wait”），此时这个滑稽老哥（线程）就不会影响后面排队的人使用ATM了（不会参与后续锁的竞争）。

滑稽老哥会一直阻塞到“取钱”条件具备了，此时在由其他滑稽老铁通过通知机制（调用notify）让其进行取钱操作（参与锁的竞争）。

3.wait/notify的使用

wait()和notify()都是Object提供的方法，任意的Object对象都可以用来wait()和notify()。

wait()需要在加锁状态中使用，如果未加锁，则会抛出异常

1）wait（）

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Object obj=new Object();
        obj.wait();
    }
}

正确操作如下

public class Demo1 {
    
    public static void main(String[] args) throws InterruptedException {
        Object obj=new Object();
        synchronized (obj){
            obj.wait();
        }
        System.out.println("结束阻塞等待");
    }
}

此时，在jconsole中，我们可以看到线程的状态是WAITING

由于没有notify（），线程将无限等待 。

注：wait（）释放锁与阻塞等待是同时进行的。

如果先是释放锁，后等待，在这之间其他线程会穿插进来，执行一些逻辑，可能会造成notify（）在阻塞等待前运行。

以ATM机为例子，如果最先来的滑稽老哥先是释放锁，随后运钱的线程马上执行完毕并通知滑稽老哥，但此时滑稽老哥还没有进入阻塞等待，运钱线程通知不会滑稽老哥感知到。再然后，系统调度回滑稽老哥进行阻塞等待，由于错过了这个通知，这个等待会持续下去，也就无法被及时唤醒了。

wait（）一共做了3件事

• 释放锁
• 进入阻塞等待，准备接受通知
• 收到通知后被唤醒，继续执行

2）notify（）

wait（）使调用的线程进入等待

notify（）则是通知wait的线程被唤醒（其他线程调用）

被唤醒的wait（）会重新竞争锁，并且在拿到锁后继续运行。

注：notify（）和sleep（）的区别

相同点：

1）默认状态下都是“死等”。

2）都提供带参数版本，提供超时时间。

不同点：

1）二者用本质的差别，notify（）使用是为了被唤醒，而sleep（）则是为了阻塞等待，并不涉及唤醒。

2）虽然sleep()会被interrupt（）唤醒，但interrupt（）是为了终止线程

3）notify（）使用需要对锁对象使用，而sleep（）则不涉及锁操作。

3）使用案例（代码）

• 3个线程，按照顺序分别打印ABC

public class Demo2 {
    //3个线程  按照ABC顺序打印
    private static Object locker1=new Object();
    private static Object locker2=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            System.out.println("A");
            synchronized (locker1){    //打印A后，通知打印B的线程
                locker1.notify();
            }
        });
        Thread t2=new Thread(()->{
           synchronized (locker1){    
               try {
                   locker1.wait();   //等待打印A的线程结束，并接受通知
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("B");
           }
           synchronized (locker2){
               locker2.notify();   //B打印结束，通知打印C的线程
           }

        });
        Thread t3=new Thread(()->{
            synchronized (locker2){
                try {
                    locker2.wait();   //等待打印B的线程结束，并结束通知
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("C");
            }

        });
        t1.start();
        t2.start();
        t3.start();
    }
}

通过wait（）和notify（），成功使用三个线程按顺序打印ABC。

增加难度 

• 3个线程按顺序循环打印ABC，循环10次

思路：每个线程循环运行10次，并通过wait()和notify()来控制打印顺序

代码如下

public class Demo3 {
    private static Object locker1=new Object();
    private static Object locker2=new Object();
    private static Object locker3=new Object();  //新加一个锁对象,控制C->A的打印
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i < 10; i++) {
                synchronized (locker3){
                    try {
                        locker3.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.print("A");
                }
                synchronized (locker1) {
                    locker1.notify();
                }
            }
        });
        Thread t2=new Thread(()->{
            for (int i = 0; i < 10; i++) {


                synchronized (locker1) {
                    try {
                        locker1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.print("B");
                }
                synchronized (locker2) {
                    locker2.notify();
                }
            }

        });
        Thread t3=new Thread(()->{
            for (int i = 0; i < 10; i++) {
                synchronized (locker2){
                    try {
                        locker2.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("C");
                }
                synchronized (locker3){
                    locker3.notify();
                }
            }

        });
        t1.start();
        t2.start();
        t3.start();

    }
}

但如果这样写，代码就陷入死锁了，因此，我们可以在主线程里主动通知t1线程开始循环。

{
    private static Object locker1=new Object();
    private static Object locker2=new Object();
    private static Object locker3=new Object();  //新加一个锁对象,控制C->A的打印
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i < 10; i++) {
                synchronized (locker3){
                    try {
                        locker3.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.print("A");
                }
                synchronized (locker1) {
                    locker1.notify();
                }
            }
        });
        Thread t2=new Thread(()->{
            for (int i = 0; i < 10; i++) {


                synchronized (locker1) {
                    try {
                        locker1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.print("B");
                }
                synchronized (locker2) {
                    locker2.notify();
                }
            }

        });
        Thread t3=new Thread(()->{
            for (int i = 0; i < 10; i++) {
                synchronized (locker2){
                    try {
                        locker2.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("C");
                }
                synchronized (locker3){
                    locker3.notify();
                }
            }

        });
        t1.start();
        t2.start();
        t3.start();
        Thread.sleep(100);  //确保每个线程都进入wait
        synchronized (locker3){
            locker3.notify();
        }
    }
}

最后成功运行，有序打印10次ABC。

二.notifyAll（）

当使用wait（）和notify（）时,3个线程都用同一个锁对象，并且都进入了wait（）等待。

此时，调用一个notify（）会发生什么？

如以下代码

import java.util.Scanner;

public class Demo{
    private static Object locker=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
              synchronized (locker){
                  System.out.println("t1wait之前");
                  try {
                      locker.wait();
                      System.out.println("t1wait之后");
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
        });
        Thread t2=new Thread(()->{
            synchronized (locker){
                System.out.println("t2wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2wait之后");
            }
        });
        Thread t3=new Thread(()->{
            synchronized (locker){
                System.out.println("t3wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t3wait之后");
            }
        });
        Thread t4=new Thread(()->{
           synchronized (locker){
               Scanner scanner=new Scanner(System.in);
               scanner.next();  //利用scanner来制造等待
               System.out.println("t4notify之前");
               locker.notify();
               System.out.println("t4notify之后");
           }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行后，我们发现，notify每次唤醒的结果有所偏差.

这是因为，notify（）是随机的唤醒一个wait（）。

若要唤醒所以线程，则需notify（）次数大于wait（）次数。

注：notify（）可以多于wait（），对程序无太大影响

或者，使用notifyAll（），一次性唤醒所以wait()

public class Demo{
    private static Object locker=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
              synchronized (locker){
                  System.out.println("t1wait之前");
                  try {
                      locker.wait();
                      System.out.println("t1wait之后");
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
        });
        Thread t2=new Thread(()->{
            synchronized (locker){
                System.out.println("t2wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2wait之后");
            }
        });
        Thread t3=new Thread(()->{
            synchronized (locker){
                System.out.println("t3wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t3wait之后");
            }
        });
        Thread t4=new Thread(()->{
           synchronized (locker){
               Scanner scanner=new Scanner(System.in);
               scanner.next();
               System.out.println("t4notify之前");
               locker.notifyAll();
               System.out.println("t4notify之后");
           }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

三.线程安全总结

1.线程安全问题产生的根本原因是系统随机调度，抢占式执行。【万恶之源】

此问题是JVM内部问题，我们难以干涉。

2.修改线程变量时，多个线程同时修改一个变量，所产生的线程问题，我们通过synchronized（）对“非原子”操作进行打包成原子的。

3.死锁的产生，有着4个必要条件

1）锁是互斥的【基本特性】
2）锁是不可被抢占的【基本特性】
假如线程1拿到了锁A，如果不线程1不主动释放锁，线程2就不能把锁抢过来

3）请求与保持。【代码逻辑】
线程1拿到锁A之后，不释放A的前提下去拿锁B。

4）循环等待，也叫环路等待【代码逻辑】。
多个线程获取锁的过程中，出现循环等待。

我们可以通过优化代码逻辑，来解决死锁问题。

4.内存可见性问题是因JVM对代码的优化造成的，可以使用volatile关键字在需注意的地方生成一些特殊指令，称为“内存屏障”，后续JVM执行到这些特殊指令，就知道不能进行优化。

5.wait（）和notify（）的使用可以控制线程的执行顺序，利于解决线程饿死问题。

以上便是全部内容，如有不对，欢迎指正~~