线程的状态
状态图:
等待唤醒案例
分析:
package demo10.WaitAndNotify;
/*
等待唤醒案例:线程之间的通信
创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子
注意:
顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法
Obejct类中的方法
void wait()
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待。
void notify()
唤醒在此对象监视器上等待的单个线程。
会继续执行wait方法之后的代码
*/
public class Demo01WaitAndNotify{
public static void main(String[] args) {
//创建锁对象,保证唯一
Object obj = new Object();
// 创建一个顾客线程(消费者)
new Thread(){
@Override
public void run() {
//一直等着买包子
while(true){
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("告知老板要的包子的种类和数量");
//调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了,开吃!");
System.out.println("---------------------------------------");
}
}
}
}.start();
//创建一个老板线程(生产者)
new Thread(){
@Override
public void run() {
//一直做包子
while (true){
//花了5秒做包子
try {
Thread.sleep(5000);//花5秒钟做包子
} catch (InterruptedException e) {
e.printStackTrace();
}
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
//做好包子之后,调用notify方法,唤醒顾客吃包子
obj.notify();
}
}
}
}.start();
}
}
package demo10.WaitAndNotify;
/*
进入到TimeWaiting(计时等待)有两种方式
1.使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
2.使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态
唤醒的方法:
void notify() 唤醒在此对象监视器上等待的单个线程。
void notifyAll() 唤醒在此对象监视器上等待的所有线程。
*/
public class Demo02WaitAndNotify {
public static void main(String[] args) {
//创建锁对象,保证唯一
Object obj = new Object();
// 创建一个顾客线程(消费者)
new Thread(){
@Override
public void run() {
//一直等着买包子
while(true){
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("顾客1告知老板要的包子的种类和数量");
//调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了,顾客1开吃!");
System.out.println("---------------------------------------");
}
}
}
}.start();
// 创建一个顾客线程(消费者)
new Thread(){
@Override
public void run() {
//一直等着买包子
while(true){
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("顾客2告知老板要的包子的种类和数量");
//调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了,顾客2开吃!");
System.out.println("---------------------------------------");
}
}
}
}.start();
//创建一个老板线程(生产者)
new Thread(){
@Override
public void run() {
//一直做包子
while (true){
//花了5秒做包子
try {
Thread.sleep(5000);//花5秒钟做包子
} catch (InterruptedException e) {
e.printStackTrace();
}
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
//做好包子之后,调用notify方法,唤醒顾客吃包子
//obj.notify();//如果有多个等待线程,随机唤醒一个
obj.notifyAll();//唤醒所有等待的线程
}
}
}
}.start();
}
}
线程间的通信
等待唤醒机制
需求分析:
package demo01.WaitAndNotify;
/*
* 资源类:包子类
* 设置包子的属性
* 皮
* 馅
* 包子的状态:有 tru,没有 false
* */
public class BaoZi{
//皮
String pi;
//馅
String xian;
//包子的状态
boolean flag = false;
}
package demo01.WaitAndNotify;
public class BaoZiPu extends Thread{
//创建一个包子的成员变量
private BaoZi bz;
//使用带参的构造方法为这个包子变量赋值
public BaoZiPu(BaoZi bz){
this.bz = bz;
}
//设置馅线程任务run:生产包子
@Override
public void run() {
int count = 0;
//设置死循环:使包子铺一直生产包子
while (true){
//必须同时同步技术保证两个线程只能有一个在执行(同步代码块)
synchronized (bz){
//对包子的状态进行判断
if(bz.flag == true){
try {
//包子调用wait方法进入等待状态
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 + "的包子。");
//生产包子需要3秒钟
try {
//这哪是放弃cpu的控制权,但不会释放锁
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//包子铺生产好了包子,修改包子的状态为true有
bz.flag = true;
//唤醒吃货线程,让吃货线程吃包子
bz.notify();
System.out.println("包子铺已经生产好了:" + bz.pi + bz.xian + ",丁家嬴开始吃包子。");
}
}
}
}
package demo01.WaitAndNotify;
public class ChiHuo extends Thread {
//创建一个包子的成员变量
private BaoZi bz;
//使用带参的构造方法为这个包子变量赋值
public ChiHuo(BaoZi bz){
this.bz = bz;
}
//设置馅线程任务run:吃包子
@Override
public void run() {
//使用死循环让吃货一直吃包子
while (true){
//保证锁对象唯一
synchronized (bz){
//对包子的状态进行判断
if(bz.flag == false){
try {
//状态为false没有,等待包子铺生产包子
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//被唤醒之后执行的代码:吃包子
System.out.println("丁家嬴正在吃" + bz.pi + bz.xian + "的包子。");
//吃完包子,更改包子的状态为false没有
bz.flag = false;
//唤醒包子铺线程生产包子
bz.notify();
System.out.println("丁家嬴已经把" + bz.pi + bz.xian + "的包子吃完了");
System.out.println("-------------------------------------");
}
}
}
}
package demo01.WaitAndNotify;
public class Demo {
public static void main(String[] args) {
//创建包子对象
BaoZi b = new BaoZi();
//创建包子铺线程
new BaoZiPu(b).start();
//创建吃货线程
new ChiHuo(b).start();
}
}