目录
一、为什么要处理线程间通信
比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，但B线程必须等A线程生产包子才能吃包子，那么线程A与线程B之间就需要线程通信—— 等待唤醒机制。
即：当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。
二、等待唤醒机制
在一个线程满足某个条件时，就进入等待状态（wait() / wait(time)）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
我们先来了解Object类的等待和唤醒方法
| 方法名 | 说明 |
|---|---|
| void wait() | 线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中 |
| void notify() | 唤醒正在等待对象监视器wait set中的单个线程 |
| void notifyAll() | 唤醒正在等待对象监视器wait set中的所有线程 |
public class Eg4 extends Thread{
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
new Thread(()->{
//细节1：wait方法与notify方法必须要由同一个锁对象调用。
//因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
synchronized (lock) {
try{
System.out.println("wait 之前->");
//细节2：wait方法与notify方法是属于Object类的方法的。
//因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
lock.wait();
System.out.println("wait 之后->");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
Thread.sleep(500);
//细节3：wait方法与notify方法必须要在`同步代码块`或者是`同步函数`中使用。
//因为：必须要`通过锁对象`调用这2个方法。否则会报java.lang.IllegalMonitorStateException异常.
synchronized (lock){
System.out.println("notify 操作后->");
lock.notify();
}
}
}运行后输出：
wait 之前->
notify 操作后->
wait 之后->
注意：
被通知的线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下：
-
如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；
-
否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态
三、生产者消费者问题
举例：
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
类似的场景，比如厨师和服务员等。
生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
分析：
包含了两类线程：
- 一类是生产者线程用于生产数据
- 一类是消费者线程用于消费数据
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
隐含了两个问题：
-
线程安全问题：因为生产者与消费者共享数据缓冲区，产生安全问题。不过这个问题可以使用同步解决。
-
线程的协调工作问题：
-
要解决该问题，就必须让生产者线程在缓冲区等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，重新开始往缓冲区添加数据。同样，也可以让消费者线程在缓冲区空时进入等待(wait)，暂停进入阻塞状态，等到生产者往缓冲区添加数据之后，再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。
-
案例：
生产者消费者案例中包含的类：
箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
①创建箱对象，这是共享数据区域
②创建消费者对象，把箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
③创建生产者对象，把箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
⑤启动线程
public class Box extends Thread{
//定义一个成员变量，表示第x瓶奶
private int milk;
//提供存储牛奶和获取牛奶的操作
public synchronized void put(int milk) {
//如果有牛奶，等待消费
if(this.milk!=0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有牛奶，就生产牛奶
this.milk = milk;
System.out.println("生产了" + this.milk + "瓶奶放入奶箱");
//唤醒其他等待的线程
this.notifyAll();
}
public synchronized void get() {
//如果没有牛奶，等待生产
if(this.milk == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果有牛奶，就消费牛奶
System.out.println("用户拿到第" + this.milk + "瓶奶");
//每次消费一瓶
this.milk--;
//唤醒其他等待的线程
this.notifyAll();
}
}public class Customer implements Runnable{
private Box b;
public Customer(Box b) {
this.b = b;
}
@Override
public void run() {
while (true) {
b.get();
}
}
}public class Producer implements Runnable{
int n1 = 2;//每次生产2瓶
int n2 = 3;//假设只供应3次
public int getCount(){
return n1 * n2;//返回共生产多少
}
private Box b;
public Producer(Box b) {
this.b = b;
}
@Override
public void run() {
//供应3次牛奶
for(int i=1; i<=n2; i++) {
b.put(n1);
}
}
}public class BoxDemoTest {
public static void main(String[] args) {
//创建奶箱对象，这是共享数据区域
Box b = new Box();
//创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
Producer p = new Producer(b);
//创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
Customer c = new Customer(b);
//创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
//启动线程
t1.start();
t2.start();
System.out.println("共供应"+p.getCount()+"瓶牛奶");
}
}运行结果：
共供应6瓶牛奶
生产了2瓶奶放入奶箱
用户拿到第2瓶奶
用户拿到第1瓶奶
生产了2瓶奶放入奶箱
用户拿到第2瓶奶
用户拿到第1瓶奶
生产了2瓶奶放入奶箱
用户拿到第2瓶奶
用户拿到第1瓶奶
四、区分sleep()和wait()
相同点：一旦执行，都会使得当前线程结束执行状态，进入阻塞状态。
不同点：
① 定义方法所属的类：sleep():Thread中定义。 wait():Object中定义
② 使用范围的不同：sleep()可以在任何需要使用的位置被调用； wait():必须使用在同步代码块或同步方法中
③ 都在同步结构中使用的时候，是否释放同步监视器的操作不同：sleep():不会释放同步监视器 ;wait():会释放同步监视器
④ 结束等待的方式不同：sleep()：指定时间一到就结束阻塞。 wait():可以指定时间也可以无限等待直到notify或notifyAll。
五、是否释放锁
任何线程进入同步代码块、同步方法之前，必须先获得对同步监视器的锁定，那么何时会释放对同步监视器的锁定呢？
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致当前线程异常结束。
- 当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程被挂起，并释放锁。
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该该线程挂起，该线程不会释放锁（同步监视器）。
-
应尽量避免使用suspend()和resume()这样的过时来控制线程。
3508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
