廖雪峰Java11多线程编程-2线程同步-4wait和notify

1.多线程协调

synchronized解决了多线程竞争的问题，我们可以在synchronized块中安全的对一个变量进行修改，但是它没有解决多线程协调的问题。

例如设计一个TaskQueue，内部通过LinkedList<>()表示一个队列。addTask()将新任务放入队列，getTask()取出队列中的第一个任务。

下面这段代码的问题：当线程执行到getTask()内部的时候，如果队列为空，会导致死循环。该线程将会100%的占用CPU，而其他线程根本不能调用addTask()方法。这是因为此时对象的this锁已经被正在执行死循环的线程获得且不会释放。

class TaskQueue{

    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s){    //线程1不能执行，因为操作对象已经被线程2锁住了

        this.queue.add(s);

    }

    public synchronized String getTask(){

        while(queue.isEmpty()){   } //线程2执行getTask()时，如果队列为空，陷入死循环

        return queue.remove();

    }

}

预期效果：

线程1通过addTask()不断往队列中添加任务，而线程2可以调用getTask()从队列中获取任务。
如果队列为空，则getTask()应该等待，直到队列中至少有一个任务再执行getTask()。

因此我们需要一种多线程协调的机制：当条件不满足时，线程进入等待状态。

2.wait

当一个线程执行getTask()时：

首先获取锁。
然后执行while条件判断：条件符合，进入等待状态。注意：进入等待状态以后，wait()方法不会返回，直到某个时刻，线程从等待状态被其他线程唤醒以后，wait()方法才会返回。
之后线程继续执行下一条语句。

wait()方法的执行机制：

首先，wait()不是一个普通的Java方法，而是定义在Object类上面的一个native方法，即是由JVM虚拟机的C代码实现的。
其次，必须在synchronized代码块中才能调用wait()方法，因为wait()方法调用的时候，线程会释放它获得的锁，wait()方法返回后，线程又回重新获得锁。我们只能在锁对象调用wait()方法。此处我们使用synchronized修饰方法，所以我们获得对象是this对象。因此只能在this对象上调用wait()方法
正是因为wait()方法会释放锁，所以其他的线程才能获得锁，并且进入addTask()方法。在addTask()方法内，我们向队列添加一个元素以后，就可以调用this.notify()来唤醒正在this对象上等待的线程，这样在wait()方法上等待的线程就可以被唤醒，然后从wait()方法返回以后继续执行。

完整的wait/notify机制：

3.示例

import java.util.LinkedList;

import java.util.Queue;

class TaskQueue{

    final Queue<String> queue = new LinkedList<>(); //定义一个LinkedList作为queue

    public synchronized String getTask() throws InterruptedException{

        System.out.println("开始执行");

        while(this.queue.isEmpty()){ //判断queue是否是空，如果空，就释放对象锁，进入等待状态。

            this.wait();

            System.out.println("继续执行");

        }

        return queue.remove();//删除queue最上面的值

    }

    public synchronized void addTask(String name){

        this.queue.add(name); //向queue添加一个任务

        this.notifyAll(); //调用notifyALL()唤醒所有正在等待的线程

        System.out.println("唤醒线程");

    }

}

class WorkerThread extends Thread {

    TaskQueue taskQueue;

    public WorkerThread(TaskQueue taskqueue){

        this.taskQueue = taskqueue;

    }

    public void run(){

        while(!isInterrupted()){ //run()方法不断的执行getTask，获取taskQueue中的任务，一旦获取到，就打印hello name

            String name;

            try{

                name = taskQueue.getTask();

            }catch (InterruptedException e){

                break;

            }

            String result = "Hello, "+name+"!";

            System.out.println(result);

        }

    }

}

public class Main{

    public static void main(String[] args) throws Exception{

        TaskQueue taskqueue = new TaskQueue();

        WorkerThread worker = new WorkerThread(taskqueue);

        worker.start();

        taskqueue.addTask("Bob");

        Thread.sleep(1000);

        taskqueue.addTask("Alice");

        Thread.sleep(1000);

        taskqueue.addTask("Tim");

        Thread.sleep(1000);

        worker.interrupt();//对worker线程调用interrupted方法让它中断

        worker.join();//调用join()方法等待worker线程的结束

        System.out.println("End");

    }

}

## 4.问题
### 4.1为什么在while循环wait，而不是一个if语句中wait ？
真是因为很有可能有2个或者更多的线程在wait()，当它们从wait返回的时候，只有1个线程有机会获得this锁。这个线程会正确执行queue.remove()方法。
但是如果我们用if语句，当这个线程执行完毕以后，其他线程获得this锁以后继续执行remove方法，可能会因为队列为空而报错，其他线程又需要重新判断条件并可能再次进入wait状态。
所以通常在while循环中调用wait方法。

唤醒当前线程的不一定是执行添加队列的线程1。当非添加队列的线程1唤醒获取队列的线程2时：
* 使用while可以判断当前队列是否为空，
* 使用if继续执行，如果队列为空，执行remove方法会报错

4.2 为什么用notifyAll()，而不是notify()

因为notify只唤醒某一个等待的线程，而notifyAll会唤醒全部的等待线程。通常来说，notifyAll更安全。

有些时候如果我们的代码逻辑考虑不周，用notify会唤醒一个线程，而其他线程可能会永远等待下去，就醒不过来了。

所以要正确的编写多线程代码是非常困难的，需要考虑的条件非常多。

4.3 这个TaskQueue有什么意义呢

如果我们在编写一个浏览器，当我们解析html的时候，每遇到一个图片链接，我们就可以把链接放到TaskQueue中，而worker线程就可以不断的从Queue中取出链接，然后把print语句替换为下载图片的代码。这个程序可以看成它能够实现后台线程顺序下载多个图片的功能。

5.总结

在synchronized内部可以调用wait()是线程进入等待状态
必须在已获得的锁对象上调用wait()方法
在synchronized内部可以调用notify/notifyAll()唤醒其他等待线程
必须在已获得的锁对象上调用notify()/notifyAll()方法

巴特西