目录
细节4:sleep()和yield()的区别;sleep()和wait()的区别
应用场景:生产者和消费者问题
假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费
如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止
如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止
分析
这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件
对于生产者,没有生产产品之前,要通知消费者等待。而生产了产品之后,又需要马上通知消费者消费
对于消费者,在消费之后,要通知生产者已经消费结束,需要继续生产新产品以供消费
1.生产和消费交替进行
2.生产者交替的生产白色馒头和黄色的玉米饼
3.生产者------仓库-------消费者(仓库中只能存放一件商品)
在生产者消费者问题中,仅有synchronized是不够的
synchronized可阻止并发更新同一个共享资源,实现了同步
synchronized不能用来实现不同线程之间的消息传递(通信)
类的设计
1.定义一个商品Product类
2.定义两个线程:生产者线程,消费者线程
3.定义测试类:创建线程并启动
注意
1.生产者线程和消费者线程是两个不同的线程
2.之前的取款线程、选手线程只要执行代码,不同线程之间没有交流
3.现在的生产者线程、消费者线程需要相互通信(还有商品吗?没有,告诉生产者,生产吧)
4.同样也需要线程同步,保证安全性(线程通信的前提是线程同步)
缺点1:没有实现交替的生产和消费
解决1:线程通信 wait() notify() notifyAll()
缺点2:和商品没有关系
解决2:添加一个商品类
缺点3:生产者生产的商品没有被消费者消费,消费者总是消费null
原因:生产者和消费者没有共用一个商品
解决:Product product = new Product();
Runnable target1 = new ProductRunnable(product);
Runnable target2 = new ConsumeRunnable(product);
缺点4:为什么消费者出现了黄色的馒头和白色的玉米饼
原因:缺少线程同步
注意:生产者和消费者都要加锁,并且必须是同一把锁
生产者关锁后,即使sleep() 释放了CPU,即使消费者得到了CPU,结果发现代码上锁,无法消费
解决
为了实现这种功能,可以借助于Object类提供的wait()、notify()和notifyAll()三个方法,这三个方法并不属于Thread类,而是属于Object类。但这三个方法必须由同步监视器对象来调用,这可分成以下两种情况。
- 对于使用synchronized修饰的同步方法,因为该类的默认实例(this)就是同步监视器,所以可以在同步方法中直接调用这三个方法。
- 对于使用synchronized修饰的同步代码块,同步监视器是synchronized后括号里的对象,所以必须使用该对象调用这三个方法。
关于这三个方法的解释如下。
- wait():导致当前线程等待,直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。该wait()方法有三种形式—无时间参数的wait(一直等待,直到其他线程通知)、带毫秒参数的wait()和带毫秒、毫微秒参数的wait()(这两种方法都是等待指定时间后自动苏醒)。调用wait()方法的当前线程会释放对该同步监视器的锁定。
- notify():唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待,则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该同步监视器的锁定后(使
用wait()方法),才可以执行被唤醒的线程。
- notifyAll():唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后,才可以执行被唤醒的线程。
线程通信的细节
细节1:进行线程通信的多个线程,要使用同一个同步监视器(product),还必须要调用该同步监视器
的wait()、notify()、notifyAll();
细节2:线程通信的三个方法
wait() 等待
在【其他线程】调用【此对象】的 notify() 方法或 notifyAll() 方法前,导致当前线程等待。
换句话说,此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器。
wait(time) 等待
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。
当前线程必须拥有此对象监视器。
notify() 通知 唤醒
唤醒在【此对象监视器】上等待的【单个】线程。
如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。【选择是任意性的】,并在对实现做出决定时发生 *
notifyAll() 通知所有 唤醒所有
唤醒在【此对象监视器】上等待的【所有】线程。
被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程【进行竞争】;
细节3:完整的线程生命周期
阻塞状态有三种
普通的阻塞 sleep,join,Scanner input.next()
同步阻塞(锁池队列) 没有获取同步监视器的线程的队列
等待阻塞(阻塞队列) 被调用了wait()后释放锁,然后进行该队列
细节4:sleep()和yield()的区别;sleep()和wait()的区别
区别1:sleep() 线程会让出CPU进入阻塞状态,但不会释放对象锁
wait() 线程会让出CPU进入阻塞状态, 【也会放弃对象锁】,进入等待【此对象】的等待锁定池
进入的阻塞状态也是不同的队列
区别2:wait只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
1.实现方案一:使用同步代码块实现线程通信
程序中可以通过一个旗标来标识仓库中是否已有商品,当旗标为false时,表明仓库中没有商品,生产者线程可以向下执行,当生产者生产一个商品后,将旗标设为true,并调用notify()或notifyAll()方法来唤醒其他线程;当生产者线程进入线程体后,如果旗标为true就调用wait()方法(调用wait()会释放同步代码块的锁)让该线程等待(代表仓库中已有商品,不能再生产了)。
当旗标为true时,表明仓库中已经存在商品,则消费者线程可以向下执行,当消费者消费商品后,将旗标设为false(代表仓库中已无商品了),并调用notify()或notifyAll()方法来唤醒其他线程;当取钱者线程进入线程体后,如果旗标为false就调用wait()方法让该线程等待。
生产者线程
public class ProduceRunnable implements Runnable{
// private Product product = new Product();
private Product product;
public ProduceRunnable() {
}
public ProduceRunnable(Product product) {
this.product = product;
}
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
@Override
public void run() {
int i=0;
while(true){
synchronized (product){
//1.如果有商品,就等待
if(product.flag){
try {
product.wait();// 等待 必须调用同步监视器的wait() 进入阻塞状态(当前同步监视器的的等待队列) 释放CPU,同时释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//2.生产并输出商品
if( i%2==0){
product.setName("馒头");
try {
Thread.sleep(1);//线程切换 进入了阻塞状态,让出了CPU,就是不释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
product.setColor("白色");
}else{
product.setName("玉米饼");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
product.setColor("黄色");
}
System.out.println("生产者生产了商品:"+product.getName()+" "+product.getColor());
//3.有商品了
product.flag = true;
//4.通知消费者
product.notify();//通知 唤醒 必须是同步监视器的notify()
}
i++;
}
}
}
消费者线程
public class ConsumeRunnable implements Runnable {
private Product product;
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
@Override
public void run() {
while(true){
synchronized (product){//product不见名称相同,关键是执行一个对象
//1.如果没有商品,就等待
if(!product.flag){
try {
product.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//2.消费商品
System.out.println("消费者在消费商品:"+product.getName()+" "+product.getColor());
//3.没有商品了
product.flag = false;
//4.通知生产者
product.notifyAll();
}
}
}
}
产品类
public class Product {
private String name;//馒头、玉米饼
private String color;//白色、黄色
boolean flag = false;//默认没有商品
public Product() {
}
public Product(String name, String color) {
this.name = name;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", color='" + color + '\'' +
'}';
}
}
测试类
public class Test {
public static void main(String[] args) {
Product product = new Product();
//创建一个生产者线程和消费者线程
Runnable target1 = new ProductRunnable(product);
Thread thread1 = new Thread(target1);
Runnable target2 = new ConsumeRunnable(product);
Thread thread2 = new Thread(target2);
//生产者和消费者线程实现交替的生产和消费
thread1.start();
thread2.start();
}
}
运行截图
2.实现方案二:使用同步方法实现线程通信
public class ProduceRunnable implements Runnable{
// private Product product = new Product();
private Product product;
public ProduceRunnable() {
}
public ProduceRunnable(Product product) {
this.product = product;
}
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
@Override
public void run() {
int i=0;
while(true){
if(i%2==0){
product.produce("馒头","白色");
}else{
product.produce("玉米饼","黄色");
}
i++;
}
}
}
public class ConsumeRunnable implements Runnable {
private Product product;
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
@Override
public void run() {
while(true){
product.consume();
}
}
}
/**
* 商品类
*/
public class Product {
private String name;//馒头、玉米饼
private String color;//白色、黄色
boolean flag = false;//默认没有商品
public Product() {
}
public Product(String name, String color) {
this.name = name;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", color='" + color + '\'' +
'}';
}
/**
* 生产商品
*/
public synchronized void produce(String name,String color){//this
//1.如果有商品,就等待
if(flag){
try {
this.wait();// 等待 必须调用同步监视器的wait() 进入阻塞状态(当前同步监视器的的等待队列) 释放CPU,同时释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//2.生产并输出商品
this.name = name;
try {
Thread.sleep(1);//线程切换 进入了阻塞状态,让出了CPU,就是不释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
this.color = color;
System.out.println("生产者生产了商品:"+getName()+" "+getColor());
//3.有商品了
flag = true;
//4.通知消费者
this.notify();//通知 唤醒 必须是同步监视器的notify()
}
/**
* 消费商品
*/
public synchronized void consume(){//this
//1.如果没有商品,就等待
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//2.消费商品
System.out.println("消费者在消费商品:"+name+" "+color);
//3.没有商品了
flag = false;
//4.通知生产者
this.notifyAll();
}
}