多线程--多线程高级使用--生产者消费者_多线程的高级运用-CSDN博客

本文链接：https://blog.csdn.net/weixin_39213232/article/details/131403208

二、对等待和唤醒的理解

1、等待的理解

➢多线程中的等待，我们使用最多的两种，分别是sleep和wait:
sleep是Thread类的静态方法，wait是0bject类的方法;

不管是sleep还是wait, 他们都可以设置等待时间，而wait可以设置无限等待;
sleep会让当前线程休眠，此时休眠的线程失去CPU的使用权，但是如果当前休眠的代码是在同步代码块中的话，sleep不会释放锁资源，所以哪怕其他线程拿到了CPU使用权，也无法进入到同步代码块中;
wait和sleep最大的区别在于，一旦你调用了wait, 那么它一定会释放锁资源，即CPU使用权和锁资源同时失去，所以wait

一定处于同步代码块下，若没有同步代码块，使用wait会报错!

不需要主动唤醒就用sleep，需要就用wait

sleep和wait区别是面试考点

2、唤醒的理解

在这里插入图片描述

interrupt唤醒需要使用的线程对象来唤醒

notify和notifyall是object类的方法

notify是唤醒一个，notifyall是唤醒所有

三、唤醒和等待案例

1、案例

模拟一个使用等待唤醒的场景:
有两个线程,分别是线程A和线程B，线程A负责摘桃子摘桃子需要花3秒钟,摘了桃子之后就给线程B去吃，B吃完进行提
示，然后程序结束;
分析:

因为线程A和线程B操作的都是一个资源~桃子，所以他们两者需要使用桃子这个资源进行加锁;
线程B- 开始进行输出，告诉线程A，他要吃桃子，然后进行休眠;
线程A获取到桃子的使用权之后， sleep3秒钟，模拟摘桃子的过程，然后摘完，唤醒线程B，让线程B开始吃桃子;

2、demo部分

public class WaitAndNotifyDemo1 {
	public static void main(String[] args) {
		//1、创建一个Object对象，模拟该对象就是一个桃子，即共享对象
		Object peach = new Object();
		//2、创建一个吃桃子的线程，该线程一开始进行输出说它想吃桃子，然后等待摘桃子线程的摘桃子过程
		new Thread() {
			public void run() {
				//因为两个线程都是使用同一个对象，所以进行加锁
				synchronized (peach) {
					System.out.println("老板，我要吃桃子！");
					//开始进入休眠，并且把这个锁对象进行释放
					try {
						//此时，这里并没有写明具体的休眠时长，它一直等待着老板线程唤醒他，喊他吃桃子
						peach.wait();
//						Thread.sleep(3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//一旦被唤醒，那么接着往后面执行
					System.out.println("谢谢老板的桃子，好吃极了！");
				}
			}
		}.start();
		//3、创建一个摘桃子的线程，该线程在获取到线程锁对象之后，开始进行摘桃子的操作
		new Thread() {
			public void run() {
				synchronized (peach) {
					try {
						//模拟摘桃子的过程
						Thread.sleep(3000);
						System.out.println("我花了3秒钟，把桃子摘下来了，给你吃！");
						//唤醒被休眠的线程
						peach.notify();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

3、demo2 增加需求两个人都要吃桃子

public class WaitAndNotifyDemo2 {
	public static void main(String[] args) {
		//1、创建一个Object对象，模拟该对象就是一个桃子，即共享对象
		Object peach = new Object();
		//2、创建一个吃桃子的线程，该线程一开始进行输出说它想吃桃子，然后等待摘桃子线程的摘桃子过程
		new Thread() {
			public void run() {
				//因为两个线程都是使用同一个对象，所以进行加锁
				synchronized (peach) {
					System.out.println("张三：老板，我要吃桃子！");
					//开始进入休眠，并且把这个锁对象进行释放
					try {
						//此时，这里并没有写明具体的休眠时长，它一直等待着老板线程唤醒他，喊他吃桃子
						peach.wait();
//						Thread.sleep(3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//一旦被唤醒，那么接着往后面执行
					System.out.println("张三：谢谢老板的桃子，好吃极了！");
				}
			}
		}.start();
		new Thread() {
			public void run() {
				//因为两个线程都是使用同一个对象，所以进行加锁
				synchronized (peach) {
					System.out.println("李四：老板，我要吃桃子！");
					//开始进入休眠，并且把这个锁对象进行释放
					try {
						//此时，这里并没有写明具体的休眠时长，它一直等待着老板线程唤醒他，喊他吃桃子
						peach.wait();
//						Thread.sleep(3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//一旦被唤醒，那么接着往后面执行
					System.out.println("李四：谢谢老板的桃子，好吃极了！");
				}
			}
		}.start();
		//3、创建一个摘桃子的线程，该线程在获取到线程锁对象之后，开始进行摘桃子的操作
		new Thread() {
			public void run() {
				synchronized (peach) {
					try {
						//模拟摘桃子的过程
						Thread.sleep(3000);
						System.out.println("我花了3秒钟，把桃子摘下来了，给你吃！");
						//唤醒被休眠的线程
//						peach.notify();
						//唤醒所有被休眠的线程
						peach.notifyAll();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

四、疑问：如果多个线程使用一个共同的资源

五、使用线程通信和唤醒机制

1、线程通信介绍

什么是线程通信

多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同，需要进行互相之间的通信来他们
对同一个变量的使用或操作。
多个线程并发执行时，在默认情况下CPU是随机切换线程的，但是当我们需要多个线程来共同完成一件任务
并且希望他们有规律的执行的时候，此时多线程之间就需要协调通信，以此来实现多线程按照我们的想法来共
同操作-份数据。

什么是等待唤醒机制

其实就是指是多个线程间的一种协作机制。
线程之间不仅有竞争(比如争夺锁对象)，也会有协作机制。就好比在公司里你和你的同事们，你们可能存
在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。就是在一个线程进行了规定操作后，就
进入等待状态(wait)，等待其他线程执行完他们的指定代码过后再将其唤醒(notify) ，在有多个线程进行等
待时，如果需要，可以使用notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。