Java多线程通信问题----生产者消费者问题

陈小哥cw

于 2019-04-13 11:18:26 发布

阅读量720

点赞数

分类专栏： Java 文章标签：多线程

本文链接：https://blog.csdn.net/qq_26838315/article/details/89279509

版权

Java 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

细节4：sleep()和yield()的区别；sleep()和wait()的区别

1.实现方案一:使用同步代码块实现线程通信

2.实现方案二:使用同步方法实现线程通信

应用场景：生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费

如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止

如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

分析

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费

对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费

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();
    }
}

陈小哥cw

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java多线程通信问题----生产者消费者问题

目录应用场景：生产者和消费者问题分析类的设计注意解决线程通信的细节细节3：完整的线程生命周期细节4：sleep()和yield()的区别；sleep()和wait()的区别1.实现方案一:使用同步代码块实现线程通信2.实现方案二:使用同步方法实现线程通信应用场景：生产者和消费者问题假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费...
复制链接

扫一扫