3-5-Java多线程-案例-生产者&消费者wait&notify

最新推荐文章于 2022-09-11 16:58:01 发布
最新推荐文章于 2022-09-11 16:58:01 发布
阅读量388 收藏 1
点赞数
分类专栏： Java并发编程 文章标签： 多线程 通信 线程 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22841811/article/details/53246604
版权

　生产者＆消费者问题

  • 多线程中最为常见的应用案例
  • 生产者消费者问题
  • 生产和消费同时执行，需要多线程

  • 但是执行的任务却不相同，处理的资源却是相同的；线程间通信．

    • 描述一下资源
    • 描述一下生产者，因为其具备自己的任务
    • 描述一下消费者，因为其具备自己的任务

代码示例-1

代码


/*描述资源*/
/*
* 属性：商品名称和编号
* 行为：对名称赋值，获取商品
* */
class Resource{
    private String name;
    private int count = 1;



    public String getName() {
        return name;
    }

    public  void setName(String name) {
        this.name = name + count;
        count++;
        System.out.println(Thread.currentThread().getName() + " ...生产者..." + this.name);
    }

    public  void out()
    {
        System.out.println(Thread.currentThread().getName() + " ...消费者..." + this.name);
    }
}

/*描述生产者*/
class Producer implements Runnable{

    private Resource resource;

    public Producer(Resource resource) {
        this.resource = resource;
    }

    public void run() {
        while (true)
        {
            resource.setName("面包");
        }
    }
}
/*描述消费者*/
class Consumer implements Runnable{
    private Resource resource;

    public Consumer(Resource resource) {
        this.resource = resource;
    }

    public void run() {
        while (true)
        {
            resource.out();
        }
    }
}
public class ProduceConsum {
    public static void main(String[] args) {
        Resource resource = new Resource();

        Producer producer = new Producer(resource);
        Consumer consumer = new Consumer(resource);

        Thread t1  = new Thread(producer);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();
    }
}

结果片段

Thread-0 ...生产者...面包173867
Thread-0 ...生产者...面包173868
Thread-0 ...生产者...面包173869
Thread-0 ...生产者...面包173870
Thread-1 ...消费者...面包173869
Thread-1 ...消费者...面包173871
Thread-1 ...消费者...面包173871

分析

数据错误需加入同步代码块
* 未加同步前问题1：运行结果错误：已经被生产很早期的商品，才被消费到
* 问题已解决 不会再消费到之前很早期的商品。但出现了问题2
* 问题2：出现了连续生产却没有消费，同时对同一个商品进行多次消费
* 希望生产一个商品就被消费掉，然后再去生产下一个

代码示例-加同步

/*描述资源*/
/*
* 属性：商品名称和编号
* 行为：对名称赋值，获取商品
* */
class Resource{
    private String name;
    private int count = 1;



    public String getName() {
        return name;
    }

    public synchronized void setName(String name) {
        this.name = name + count;
        count++;
        System.out.println(Thread.currentThread().getName() + " ...生产者..." + this.name);
    }

    public synchronized void out()
    {
        System.out.println(Thread.currentThread().getName() + " ...消费者..." + this.name);
    }
}

/*描述生产者*/
class Producer implements Runnable{

    private Resource resource;

    public Producer(Resource resource) {
        this.resource = resource;
    }

    public void run() {
        while (true)
        {
            resource.setName("面包");
        }
    }
}
/*描述消费者*/
class Consumer implements Runnable{
    private Resource resource;

    public Consumer(Resource resource) {
        this.resource = resource;
    }

    public void run() {
        while (true)
        {
            resource.out();
        }
    }
}
public class ProduceConsum {
    public static void main(String[] args) {
        Resource resource = new Resource();

        Producer producer = new Producer(resource);
        Consumer consumer = new Consumer(resource);

        Thread t1  = new Thread(producer);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();
    }
}

结果片段

Thread-0 ...生产者...面包51722
Thread-0 ...生产者...面包51723
Thread-0 ...生产者...面包51724
Thread-0 ...生产者...面包51725
Thread-0 ...生产者...面包51726
Thread-0 ...生产者...面包51727
Thread-0 ...生产者...面包51728
Thread-0 ...生产者...面包51729
Thread-0 ...生产者...面包51730
Thread-1 ...消费者...面包51730
Thread-1 ...消费者...面包51730
Thread-1 ...消费者...面包51730
Thread-1 ...消费者...面包51730
Thread-1 ...消费者...面包51730
Thread-1 ...消费者...面包51730

问题分析

  • 问题2：出现了连续生产却没有消费，同时对同一个商品进行多次消费
  • 希望生产一个商品就被消费掉，然后再去生产下一个
  • 生产者生么时候应该生产呢？消费者生么时候应该消费呢？
  • 当盘子中没有面包时，就生产，如果有了面包就不要生产
  • 当盘子中已有面包时，就消费，如果没了面包就不消费

代码示例-wait/notify


/*描述资源*/
/*
* 属性：商品名称和编号
* 行为：对名称赋值，获取商品
* */
class Resource{
    private String name;
    private int count = 1;
    private boolean flag = false;


    public String getName() {
        return name;
    }

    public synchronized void setName(String name) {
        if (flag)
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name + count;
        count++;
        System.out.println(Thread.currentThread().getName() + " ...生产者..." + this.name);
        flag = true;
        notify();
    }

    public synchronized void out()  {
        if (!flag)
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " ...消费者..." + this.name);
        flag = false;
        notify();
    }
}

/*描述生产者*/
class Producer implements Runnable{

    private Resource resource;

    public Producer(Resource resource) {
        this.resource = resource;
    }

    public void run() {
        while (true)
        {
            resource.setName("面包");
        }
    }
}

/*描述消费者*/
class Consumer implements Runnable{
    private Resource resource;

    public Consumer(Resource resource) {
        this.resource = resource;
    }

    public void run() {
        while (true)
        {
            resource.out();
        }
    }
}

public class ProduceConsum {
    public static void main(String[] args) {
        Resource resource = new Resource();

        Producer producer = new Producer(resource);
        Consumer consumer = new Consumer(resource);

        Thread t1  = new Thread(producer);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();
    }
}

结果片段

Thread-0 ...生产者...面包90079
Thread-1 ...消费者...面包90079
Thread-0 ...生产者...面包90080
Thread-1 ...消费者...面包90080
Thread-0 ...生产者...面包90081
Thread-1 ...消费者...面包90081
Thread-0 ...生产者...面包90082
Thread-1 ...消费者...面包90082
Thread-0 ...生产者...面包90083
Thread-1 ...消费者...面包90083
Thread-0 ...生产者...面包90084
Thread-1 ...消费者...面包90084
Thread-0 ...生产者...面包90085
Thread-1 ...消费者...面包90085
Thread-0 ...生产者...面包90086
Thread-1 ...消费者...面包90086
Thread-0 ...生产者...面包90087
Thread-1 ...消费者...面包90087
Thread-0 ...生产者...面包90088
Thread-1 ...消费者...面包90088
Thread-0 ...生产者...面包90089
Thread-1 ...消费者...面包90089
Thread-0 ...生产者...面包90090

分析

  • 生产者生产了商品后应该告诉消费者来消费。这时的生产者应该处于等待状态
  • 消费者消费了商品后，应该告诉生产者，这时候消费者应该等待
  • 等待wait:会让线程处于等待，将线程临时存储到线程池中。

  • 唤醒notify notifyAll:唤醒在此锁上等待的单个线程。如果所有线程都在此对象上等待，那么就会唤醒任意一个等待的线程

  • 记住：这些方法必须使用在同步中，因为必须要标识wait，notify等方法所属的锁，同一个锁上的notify只能唤醒该锁上的被wait的线程

  • 为什么这些方法定义在object中？

  • 因为这些方法必须标识所属的锁，而锁可以是任意对象，任意对象可以调用的方法必然是Object中的方法。

wait&notify

这些方法必须是在同步中使用,因为当前线程必须拥有此对象监视器(必须要标识wait,notify所属的锁),同一个锁上的notify,只能唤醒该锁上的被wait的线程.

wait:会让线程处于等待状态,其实就是将线程临时存储到线程池中.
public final void wait() throws InterruptedException
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。 
当前线程必须拥有此对象监视器,该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。 

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用： 

synchronized (obj) {
    while (<condition does not hold>)
    obj.wait();
    ... // Perform action appropriate to condition
     }
 此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。 

notify 会唤醒任意一个等待的线程
public final void notify()唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。 

此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者： 

通过执行此对象的同步实例方法。 
通过执行在此对象上进行同步的 synchronized 语句的正文。 
对于 Class 类型的对象，可以通过执行该类的同步静态方法。 
一次只能有一个线程拥有对象的监视器。 

notifyAll 会唤醒线程池中所有等待的线程.
public final void notifyAll()唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。 

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

代码示例-多生产多消费的问题

　代码

其他不变仅仅增加两个线程

public class ProduceConsum {
    public static void main(String[] args) {
        Resource resource = new Resource();

        Producer producer = new Producer(resource);
        Consumer consumer = new Consumer(resource);

        Thread t1  = new Thread(producer);
        Thread t2  = new Thread(producer);
        Thread t3  = new Thread(consumer);
        Thread t4 = new Thread(consumer);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

　结果片段

Thread-1 ...生产者...面包129360
Thread-3 ...消费者...面包129360
Thread-2 ...消费者...面包129360
Thread-1 ...生产者...面包129361
Thread-3 ...消费者...面包129361
Thread-2 ...消费者...面包129361
Thread-1 ...生产者...面包129362
Thread-3 ...消费者...面包129362
Thread-2 ...消费者...面包129362
Thread-1 ...生产者...面包129363
Thread-3 ...消费者...面包129363
Thread-2 ...消费者...面包129363
Thread-1 ...生产者...面包129364
Thread-3 ...消费者...面包129364

　分析

生产了商品没有被消费,同一个商品被消费多次.

出现原因:假设t1t2为生产者 t3t4为消费者 t1生产->t1等待->t2等待->t3消费->t3等待->t4等->t1生产->t2被唤醒(此时从wait开始不再判断标记) t1生产的第二个商品未被消费.

被唤醒的线程未判断标记,造成了问题的产生
解决:让被唤醒的线程必须判断标记.使用while,把if转为while判断

while判断后死锁,

原因:生产方唤醒了线程池中生产方
解决:希望本方要唤醒对方.(把notify换位notifyALl)

class Resource
{
    private String name;
    private int count = 1;

    //定义标记。
    private boolean flag = false;

    //1,提供设置的方法。
    public synchronized void set(String name)//
    {

        if(flag)
            try{this.wait();}catch(InterruptedException e){}// t1等  t2等
        //给成员变量赋值并加上编号。
        this.name = name + count;//商品1  商品2  商品3
        //编号自增。
        count++;//2 3  4
        //打印生产了哪个商品。
        System.out.println(Thread.currentThread().getName()+"......生产者...."+this.name);//生产 商品1  生产商品2  生产商品3

        //将标记改为true。
        flag = true;
        //唤醒消费者。
        this.notify();
    }
    public synchronized void out()//
    {
        if(!flag)
            try{this.wait();}catch(InterruptedException e){}//t3等  //t4等
        System.out.println(Thread.currentThread().getName()+"....消费者...."+this.name);//消费 商品1
        //将标记该为false。
        flag = false;
        //唤醒生产者。
        this.notify();
    }
}

代码示例-多生产多消费解决

代码


class Resource
{
    private String name;
    private int count = 1;

    //定义标记。
    private boolean flag = false;

    //1,提供设置的方法。
    public synchronized void set(String name)//
    {

        while(flag)
            try{this.wait();}catch(InterruptedException e){}// t1等  t2等
        //给成员变量赋值并加上编号。
        this.name = name + count;//商品1  商品2  商品3
        //编号自增。
        count++;//2 3  4
        //打印生产了哪个商品。
        System.out.println(Thread.currentThread().getName()+"......生产者...."+this.name);//生产 商品1  生产商品2  生产商品3

        //将标记改为true。
        flag = true;
        //唤醒消费者。
        this.notifyAll();
    }
    public synchronized void out()//
    {
        while(!flag)
            try{this.wait();}catch(InterruptedException e){}//t3等  //t4等
        System.out.println(Thread.currentThread().getName()+"....消费者...."+this.name);//消费 商品1
        //将标记该为false。
        flag = false;
        //唤醒生产者。
        this.notifyAll();
    }
}

//2,描述生产者。
class Producer implements Runnable
{
    private Resource r ;
    // 生产者一初始化就要有资源，需要将资源传递到构造函数中。
    Producer(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.set("面包");
        }
    }
}

//3,描述消费者。
class Consumer implements Runnable
{
    private Resource r ;
    // 消费者一初始化就要有资源，需要将资源传递到构造函数中。
    Consumer(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}




class ThreadDemo10
{
    public static void main(String[] args)
    {
        //1,创建资源对象。
        Resource r = new Resource();

        //2,创建线程任务。
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        //3,创建线程。
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

分析

效率变低,因为唤醒了所有的锁,然而只有一个消费者可以消费.

蛋子哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java代码-例子3-5
07-15
java代码-例子3-5
java—多线程的通信、生产者与消费者模式
12-21
一、重点知识 isDaemon 判断是否为守护线程。...如果没有线程处于wait状态，调用notify此时是一个空唤醒 stringBuffer中的同步方法，都是非静态的，因为共用一个this锁就可以了，线程进去调用他的一个方法
Java多线程+网银取款案例精讲
07-28
课程简介本课程是《Java初级至应用》系统课程的第十章，全套课程精细讲解，课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java工程师或系统架构师岗位，课程提供全套代码笔记其它相关素材及答疑服务，可谓是低投资高回报！学习前或学习后有任何疑问请在课程中提问，老师看到会第一时间回复！
最简实例说明wait、notify、notifyAll的使用方法
幸福的懦夫
08-20 816
/** *  转载请注明作者longdick    http://longdick.iteye.com * */   wait()、notify()、notifyAll()是三个定义在Object类里的方法，可以用来控制线程的状态。 这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。   如果对象调用了wait方法就会使持有该对象的线程...
Java多线程13：手写生产者-消费者模式
何哥的博客
09-12 1895
一、Object的wait、notify和notifyAll方法 1.1、wait方法 当一个线程调用一个共享变量的wait（）方法时，该调用线程会被阻塞挂起（进入waiting状态），直到发生下面几件事情之一才能返回： 其他线程调用了该共享对象的notify（）或者notifyAll（）方法； 其他线程调用了该线程的interrupt（）方法，该线程抛出InterruptedException异常返回。 另外需要注意的是，如果调用wait（）方法的线程没有事先获取该对象的监视器锁，则调用w...
Java基础进阶多线程-生产者和消费者模式
qq_46096136的博客
09-11 7621
1、什么是“生产者和消费者模式”？2、3、。。，，只是通知，
生产者消费者问题-代码详解（Java多线程）
辰兮要努力
06-13 9287
文章目录一、生产者消费者问题二、代码实现三、拓展知识 一、生产者消费者问题 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。 该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。 生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲
多线程经典案例（生产者--消费者）
WuHuaSen的博客
03-20 930
多线程开发中有一个经典的操作案例，就是“生产者-消费者”案例，生产者不的生产产品，消费者不断地取走产品；此案例涉及线程同步、线程休眠、线程等待、线程唤起等操作以及之间是如何搭配使用的方法。 示例讲解： 本示例模拟中生产者由“厨师”担任，消费者由“顾客担任”，模拟做菜与上菜的一个简单操作。类之间的关系如图： 初始代码块分解： Food类为食物类，内置了set（Food food）生产食物和get（Food food）消费取走食物方法，Food类有两个属性分别是Na...
如何在Java中正确使用 wait, notify 和 notifyAll
12-22
wait， notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 　在 Java 中可以用 wait、notify 和 notifyAll 来实现...
用Python的线程来解决生产者消费问题的示例
12-25
我们将使用Python线程来解决Python中的生产者—消费者问题。这个问题完全不像他们在学校中说的那么难。 如果你对生产者—消费者问题有了解，看这篇博客会更有意义。 为什么要关心生产者—消费者问题： 可以帮你更好...
【并发编程】 — 线程间的通信wait、notify、notifyAll
12-21
三个线程顺序打印问题2.1.1 题目2.1.2 题目分析2.1.3 我的答案2.2 生产者消费者问题2.2.1 题目2.2.2 题目分析2.2.3 我的答案 源码地址：https://github.com/nieandsun/concurrent-study.git 1 wait、notify、...
java多线程（生产者与消费者）
07-05
生产者消费者模式是java多线程经典的安全，它用到了同步，资源共享，wait,notify等技术。
3-3-Java多线程-案例-银行存钱&同步函数
蛋子哥的博客
11-20 1103
银行存钱案例 两个客户到一个银行去存钱，每个客户一次存100，存三次。 问题：改程序是否有安全问题，如果有写出分析过程并定义解决方案 代码示例-未修改前代码class Bank{ private int sum; private Object obj = new Object(); public void add(int num) { sale(num
2-3-Java多线程-多线程内存图&线程名称
蛋子哥的博客
11-20 900
多线程内存图 多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。 进行方法的压栈和弹栈。 当执行线程的任务结束了，线程自动在栈内存这种释放了。 但是当所有的执行线程都结束了，进程就结束了 Java的并发采用的是共享内存模型（而非消息传递模型），线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。多个线程之间是不能直接传递数据交互的，它们之间的交互只
2-1-Java多线程-主线程的运行方式
蛋子哥的博客
11-20 888
>**当主线程在这个程序中执行时,如果遇到了一定业务逻辑导致执行时间过长,无法执行下面的程序,可不可以实现一个主线程负责执行其中一个,由另一个线程负责其他代码的执行,实现多部分代码同时执行.** >**这就是多线程技术可以解决的问题.** ## 如何创建线程 >创建线程的两种方式： 一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子
2-5-Java多线程-创建线程的Runnable接口方法及Thread源码解析
蛋子哥的博客
11-20 559
创建线程的Runnable接口方法 public interface Runnable Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。 设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如，Thread 类实现了 Runnable。激活的意思是说某个线程已启动并且尚未停止。 此外，
2-2-Java多线程-继承Thread类原理
蛋子哥的博客
11-20 495
继承Thread类原理继承Thread类 因为Thrad类描述线程事务，具备线程的基本功能 为什么不直接创建Thread类的对象 这么做没有错，但是该start方法调用的是thread类中的run方法这个方法不做任何操作就返回。更重要的是这个run方法中并没有定义我们需要让线程执行的代码。 创建线程的目的是 是为了建立单独的执行路径，让多部分代码实现同时执行，也就是说线程创建并执行需要给
3-2-Java多线程-案例-单例设计模式出现的问题
蛋子哥的博客
11-20 410
单例设计模式出现的问题代码示例class Demo implements Runnable{ public void run() { Single.getInstance(); } }饿汉式 饿汉式多线程并发没有问题 class Single { private static final Single SINGLE = new Single();
Java实现生产者-消费者
最新发布
06-10
生产者-消费者是一个经典的多线程编程问题，Java提供了多种实现方式，下面给出一种基于wait()和notify()方法的实现： ``` public class ProducerConsumer { private List<Integer> buffer = new ArrayList(); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值