1、概述
针对同一个资源的操作有不同的线程
2、例如：
线程 A 和线程 B ，针对同一个对象（包子）进行操作
3、等待唤醒机制
3-1、概述
通过一定的手段使各个线程之间能有效的利用资源，是多线程之间的协作机制
3-2、wait() 与 notify()
一个线程进行了规定操作以后，就进入等待状态（wait），等待其他线程执行完操作后，再将其唤醒（notify）。若有多个线程等待唤醒的话，可以使用
notifyAll()
3-3、等待唤醒机制 解决 线程间的通信
wait() 线程不再活动，不参与调度，不浪费CPU，不去竞争锁，等待唤醒（notify）
notify() 选取通知对象中的线程，并释放
notifyAll() 释放所有等待中的线程
3-4、注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行
3-5、调用wait和notify方法需要注意的细节
wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。
4、线程的状态转换
5、代码
创建 Baozi.java
package duoxiancheng;
public class Baozi {
String pi;
String xian;
boolean flag = false;//包子资源状态，包子是否存在
}
创建 Baoziopu.java
package duoxiancheng;
public class Baozipu extends Thread {
private Baozi bz;//创建包子变量
public Baozipu(Baozi bz){
this.bz = bz;
}
@Override
public void run() {//设置线程任务，生产包子
int count = 0;
while (true){//让包子铺一直生产包子
synchronized (bz){
if (bz.flag){//如果有包子
try{
bz.wait();//如果包子铺有包子，进入线程等待
}catch (InterruptedException e){
e.printStackTrace();
}
}
if (count % 2 == 0){
bz.pi = "薄皮";
bz.xian = "猪肉";
}else {
bz.pi = "冰皮";
bz.xian = "韭菜";
}
count ++;
System.out.println("包子铺正在生产" + bz.pi + bz.xian + "包子");
try{
Thread.sleep(3000);
}catch (InterruptedException e){
e.printStackTrace();
}
bz.flag = true;//包子铺生产好了包子，修改包子的状态为 有
System.out.println("包子铺已经生产好了" + bz.pi + bz.xian + "的包子，吃货们可以进来吃了");
bz.notify();//并唤醒吃货
}
}
}
}
创建 Chihuo.java
package duoxiancheng;
public class Chihuo extends Thread {
private Baozi bz;
public Chihuo(Baozi bz){
this.bz = bz;
}
@Override
public void run() {//设置线程任务 吃包子
while (true){//吃货一直吃包子
synchronized (bz){
if (bz.flag == false){//如果没有包子
try{
bz.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
System.out.println("吃货正在吃" + bz.pi + bz.xian + "的包子");
bz.flag = false;//吃货吃完包子，修改包子的状态为 false
System.out.println("吃货已经把" + bz.pi + bz.xian + "的包子吃完，包子铺开始生产包子");
bz.notify();//唤醒包子铺线程生产包子
System.out.println("————————————————————————————————");
}
}
}
}
创建 Demo.java
package duoxiancheng;
public class Demo {
public static void main(String[] args){
Baozi bz = new Baozi();
Baozipu bzp = new Baozipu(bz);
bzp.start();
Chihuo ch = new Chihuo(bz);
ch.start();
}
}
运行 Demo 显示：
个人理解：
package duoxiancheng02;
public class Demo {
public static void main(String[] args){//main 方法，程序执行的入口
Baozi bz = new Baozi();//创建包子对象
Baozipu bzp = new Baozipu(bz);//创建包子铺线程，开启生产包子
bzp.start();
Chihuo ch = new Chihuo(bz);//创建吃货线程，开启吃包子
ch.start();
}
}
class Baozi{//创建包子类
boolean flag = false;//定义包子资源状态，是否存在
}
class Baozipu extends Thread{//创建包子铺线程，继承 Thread 类
private Baozi bz;//在成员位置创建包子变量
public Baozipu(Baozi bz){//使用带参构造方法为包子变量赋值
this.bz = bz;
}
@Override
public void run() {//设置包子铺线程的线程任务 run 方法，生产包子
while (true){//让包子铺一直生产包子
synchronized (bz){
if (bz.flag){//如果有包子
try{
bz.wait();//让包子铺线程进入包子的线程监狱等待
}catch (Exception e){
e.printStackTrace();
}
}
System.out.println("包子铺正在生产包子........");
try{
Thread.sleep(3000);//生产包子需要3秒钟，线程休眠
}catch (Exception e){
e.printStackTrace();
}
bz.flag = true;//修改包子状态为有
bz.notify();//唤醒吃货线程进入包子线程，吃包子
System.out.println("包子铺已经生产好了包子,吃货们可以吃了");
}
}
}
}
class Chihuo extends Thread{//创建吃货线程
private Baozi bz;//创建包子变量
public Chihuo(Baozi bz){//使用有参构造函数为包子变量赋值
this.bz = bz;
}
@Override
public void run() {//设置吃货线程的线程任务 run 方法，负责吃包子
while (true){//一直吃
synchronized (bz){
if (!bz.flag){//如果没有包子
try{
bz.wait();//让吃货线程进入包子线程监狱等待
}catch (Exception e){
e.printStackTrace();
}
}
System.out.println("吃货们正在吃包子。。。。。。");
bz.flag = false;//吃货吃完包子后，修改包子状态
System.out.println("吃货们已经把包子吃完了，请包子铺马上开始生产包子");
bz.notify();//唤醒线程监狱中等待的包子铺线程
System.out.println("--------------------------");
}
}
}
}
6、扩展代码
package duoxiancheng02;
public class Demo{
public static void main(String[] args){
Tesla t = new Tesla();//创建特斯拉汽车对象
Chongdian cd = new Chongdian(t);//创建充电线程
cd.start();
Lvyou ly = new Lvyou(t);//创建旅游线程
ly.start();
}
}
class Tesla{
boolean flag = false;//定义特斯拉汽车是否有电
}
class Chongdian extends Thread{
private Tesla t;
public Chongdian(Tesla t){
this.t = t;
}
@Override
public void run() {
while (true){//一直充电
synchronized (t){
if (t.flag){//判断特斯拉汽车是否有电，如果有
try{
t.wait();//如果有电，让充电线程进入线程等待
}catch (Exception e){
e.printStackTrace();
}
}
System.out.println("我的特斯拉汽车没电了，正在充电中.........");
try{
Thread.sleep(3000);//休眠3秒钟
}catch (Exception e){
e.printStackTrace();
}
t.flag = true;//修改汽车的状态为有电
System.out.println("我的特斯拉汽车有电了，我带你们去旅游吧");
t.notify();//唤醒旅游线程进入
}
}
}
}
class Lvyou extends Thread{
private Tesla t;
public Lvyou(Tesla t){
this.t = t;
}
@Override
public void run() {
while (true){
synchronized (t){
if (!t.flag){
try{
t.wait();
}catch (Exception e){
e.printStackTrace();
}
}
System.out.println("特斯拉有电了，我们正在旅游中。。。。。。。。");
t.flag = false;
System.out.println("车快没电了，我们需要回家充电");
t.notify();
System.out.println("--------------------------------");
}
}
}
}
---------------------
作者：CSDN-Lemon
来源：CSDN
原文：https://blog.csdn.net/weixin_43860260/article/details/93650855
版权声明：本文为博主原创文章，转载请附上博文链接！
