Java多线程（五）生产者、消费者案例

最新推荐文章于 2023-11-09 13:08:51 发布
最新推荐文章于 2023-11-09 13:08:51 发布
阅读量753 收藏 1
点赞数 2
分类专栏： Java SE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fox_bert/article/details/125392327
版权

一、wait、notify

1、案例一【生产完再消费，消费完再生产】

生产完再消费，消费完再生产：满足数量后才开始进行消费，消费完全部再进行生产

一只猫钓鱼，一次钓一条，放桶里，满五条后，拿回家。
另一只猫吃鱼，一次吃一条，吃完后，让钓鱼猫再去钓鱼 ，如此继续

（1）水桶：用来放鱼

/**
 * 水桶：用来放鱼
 */
public class Bucket {

    public static final int MAX_FISH_COUNT = 5;

    int fishCount;

    public int getFishCount() {
        return fishCount;
    }

    public void doPutFish() {
        fishCount++;
    }

    public void doRemoveFish() {
        if (fishCount > 0) {
            fishCount--;
        }
    }
}

（2）创建生产者和消费者

/**
 * 生产猫
 */
public class ProducerCat implements Runnable {

    private Bucket bucket;

    public ProducerCat(Bucket bucket) {
        this.bucket = bucket;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (bucket) {
                if (bucket.getFishCount() >= Bucket.MAX_FISH_COUNT) {
                    System.out.println(Thread.currentThread().getName() + "桶里的鱼已经满了，可以拿桶回家了：" + bucket.getFishCount());
                    try {
                        System.out.println(Thread.currentThread().getName() + "【通知】其他猫准备吃鱼");
                        //先通知【等待池】：可以将随机一个线程放入【锁池】（准备获取锁）；只有当前拥有锁的线程释放锁，才能被【锁池】中别的线程争抢
                        bucket.notify();

                        System.out.println(Thread.currentThread().getName() + "【等待】生产猫------进入等待：桶里已经满了");
                        //再释放锁
                        bucket.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    bucket.doPutFish();
                    System.out.println(Thread.currentThread().getName() + "【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有" + bucket.getFishCount() + "条鱼");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

/**
 * 消费猫
 */
public class ConsumerCat implements Runnable {

    private Bucket bucket;

    public ConsumerCat(Bucket bucket) {
        this.bucket = bucket;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (bucket) {
                if (bucket.getFishCount() <= 0) {
                    System.out.println(Thread.currentThread().getName() + "桶里的鱼吃完了：" + bucket.getFishCount());
                    try {
                        System.out.println(Thread.currentThread().getName() + "【通知】钓鱼猫准备钓鱼");
                        //先通知【等待池】：可以将随机一个线程放入【锁池】（准备获取锁）；只有当前拥有锁的线程释放锁，才能被【锁池】中别的线程争抢
                        bucket.notify();

                        System.out.println(Thread.currentThread().getName() + "【等待】消费猫------进入等待");
                        //再释放锁
                        bucket.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    bucket.doRemoveFish();
                    System.out.println(Thread.currentThread().getName() + "【吃鱼】消费猫------吃掉一条鱼,桶里还剩" + bucket.getFishCount() + "条鱼");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

（3）main方法测试

/**
 * 【生产完再消费，消费完再生产：满足数量后才开始进行消费，消费完全部再进行生产】
 * 一只猫钓鱼，一次钓一条，放桶里，满五条后，拿回家。
 * 另一只猫吃鱼，一次吃一条，吃完后，让钓鱼猫再去钓鱼 ，如此继续
 */
public class Demo {

    public static void main(String[] args) {
        Bucket bucket = new Bucket();
        new Thread(new ConsumerCat(bucket)).start();
        new Thread(new ProducerCat(bucket)).start();
    }
}

 （4）执行结果

Thread-0桶里的鱼吃完了：0
Thread-0【通知】钓鱼猫准备钓鱼
Thread-0【等待】消费猫------进入等待
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有1条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有2条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有3条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有4条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有5条鱼
Thread-1桶里的鱼已经满了，可以拿桶回家了：5
Thread-1【通知】其他猫准备吃鱼
Thread-1【等待】生产猫------进入等待：桶里已经满了
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩4条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩3条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩2条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩1条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩0条鱼
Thread-0桶里的鱼吃完了：0
Thread-0【通知】钓鱼猫准备钓鱼
Thread-0【等待】消费猫------进入等待
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有1条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有2条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有3条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有4条鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有5条鱼
Thread-1桶里的鱼已经满了，可以拿桶回家了：5
Thread-1【通知】其他猫准备吃鱼
Thread-1【等待】生产猫------进入等待：桶里已经满了
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩4条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩3条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩2条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩1条鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩0条鱼

2、案例二【边生产边消费】

【边生产边消费】生产者：只要不大于5就一直去生产；消费者：只要有就可以一直去消费

桶里最多放5条鱼
一只猫钓鱼，一次钓一条
放桶里
同时通知另一只猫吃鱼，一次吃一条
同时通知钓鱼猫再钓鱼 （只要桶里鱼不满足5条）
如此继续 

（1）水桶：用来放鱼

/**
 * 水桶：用来放鱼
 */
public class Bucket {

    public static final int MAX_FISH_COUNT = 5;

    int fishCount;

    public int getFishCount() {
        return fishCount;
    }

    public void doPutFish() {
        fishCount++;
    }

    public void doRemoveFish() {
        if (fishCount > 0) {
            fishCount--;
        }
    }
}

（2）创建生产者和消费者

/**
 * 生产猫
 */
public class ProducerCat implements Runnable {

    private Bucket bucket;

    public ProducerCat(Bucket bucket) {
        this.bucket = bucket;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (bucket) {
                //桶里大于等于5条就满了，钓鱼猫停止钓鱼，通过wait进入等待池，并释放锁
                if (bucket.getFishCount() >= Bucket.MAX_FISH_COUNT) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "【等待】生产猫------进入等待：桶里已经满了");
                        //释放锁
                        bucket.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //桶里小于5条就始终钓鱼，然后通知吃鱼猫
                try {
                    //继续钓鱼
                    bucket.doPutFish();
                    System.out.println(Thread.currentThread().getName() + "【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有" + bucket.getFishCount() + "条鱼");
                    Thread.sleep(1000);
                    //只要有鱼，吃鱼猫就可以吃鱼了
                    System.out.println(Thread.currentThread().getName() + "【通知】其他猫准备吃鱼");
                    //先通知【等待池】：可以将随机一个线程放入【锁池】（准备获取锁）；只有当前拥有锁的线程释放锁，才能被【锁池】中别的线程争抢
                    bucket.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/**
 * 消费猫
 */
public class ConsumerCat implements Runnable {

    private Bucket bucket;

    public ConsumerCat(Bucket bucket) {
        this.bucket = bucket;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (bucket) {
                //桶里没有鱼：吃鱼猫停止吃鱼，通过wait进入等待池，并释放锁
                if (bucket.getFishCount() <= 0) {
                    System.out.println(Thread.currentThread().getName() + "桶里的鱼吃完了：" + bucket.getFishCount());
                    try {
                        System.out.println(Thread.currentThread().getName() + "【等待】消费猫------进入等待");
                        //释放锁
                        bucket.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    //桶里有鱼就可以进行吃鱼
                    bucket.doRemoveFish();
                    System.out.println(Thread.currentThread().getName() + "【吃鱼】消费猫------吃掉一条鱼,桶里还剩" + bucket.getFishCount() + "条鱼");
                    Thread.sleep(2000);
                    if (bucket.getFishCount() < Bucket.MAX_FISH_COUNT) {
                        System.out.println(Thread.currentThread().getName() + "【通知】桶里不满，还剩" + bucket.getFishCount() + "条鱼，可以通知钓鱼猫钓鱼了");
                        //先通知【等待池】：可以将随机一个线程放入【锁池】（准备获取锁）；只有当前拥有锁的线程释放锁，才能被【锁池】中别的线程争抢
                        bucket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（3）main方法测试

/**
 * 【边生产边消费：生产者：只要不大于5就一直去生产；消费者：只要有就可以一直去消费】
 * 桶里最多放5条鱼，
 * 一只猫钓鱼，一次钓一条
 * 放桶里
 * 同时通知另一只猫吃鱼，一次吃一条
 * 同时通知钓鱼猫再钓鱼 （只要桶里鱼不满足5条）
 * 如此继续
 */
public class Demo {

    public static void main(String[] args) {
        Bucket bucket = new Bucket();
        new Thread(new ConsumerCat(bucket)).start();
        new Thread(new ProducerCat(bucket)).start();
    }
}

 （4）执行结果

Thread-0桶里的鱼吃完了：0
Thread-0【等待】消费猫------进入等待
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有1条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩0条鱼
Thread-0【通知】桶里不满，还剩0条鱼，可以通知钓鱼猫钓鱼了
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有1条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩0条鱼
Thread-0【通知】桶里不满，还剩0条鱼，可以通知钓鱼猫钓鱼了
Thread-0桶里的鱼吃完了：0
Thread-0【等待】消费猫------进入等待
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有1条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有2条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有3条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩2条鱼
Thread-0【通知】桶里不满，还剩2条鱼，可以通知钓鱼猫钓鱼了
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩1条鱼
Thread-0【通知】桶里不满，还剩1条鱼，可以通知钓鱼猫钓鱼了
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有2条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有3条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有4条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有5条鱼
Thread-1【通知】其他猫准备吃鱼
Thread-1【等待】生产猫------进入等待：桶里已经满了
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩4条鱼
Thread-0【通知】桶里不满，还剩4条鱼，可以通知钓鱼猫钓鱼了
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩3条鱼
Thread-0【通知】桶里不满，还剩3条鱼，可以通知钓鱼猫钓鱼了
Thread-0【吃鱼】消费猫------吃掉一条鱼,桶里还剩2条鱼
Thread-0【通知】桶里不满，还剩2条鱼，可以通知钓鱼猫钓鱼了
Thread-1【钓鱼】生产猫------钓鱼掉到一条鱼,桶里有3条鱼

Marvin-Fox
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 多线程生产者消费者模型demo
03-31
java 多线程生产者消费者模型demo
Java多线程：生产者-消费者模型
子夜的个人博客
02-10 1160
生产者-消费者模型
手把手教你实现 生产者消费者模式
胤凯的博客
11-09 485
生产者消费者模式是一种并发设计模式，用于解决多线程环境下生产者和消费者之间的协作和数据共享问题。
生产者消费者模型（学习笔记）——java多线程典型案例
R_sir007的博客
08-06 516
生产者消费者模型是一种经典的并发编程模型，它描述的是一个共享资源池的问题。在这个模型中，生产者负责生产数据并将数据放入队列中，消费者线程则负责从队列中取出数据并消费。这个队列通常被设计成是线程安全的，以保证生产者和消费者能够同时操作它而不会出现数据错乱的问题。生产者消费者模型是一种非常重要的并发编程模型，它可以广泛应用于各种场景中，比如生产者线程生产数据，消费者线程处理数据，可以用于异步消息处理、多线程数据处理等。
Java多线程（含生产者消费者模式详解）
yangsf_的博客
03-26 6849
Java简单并发问题解决！含生产者消费者模式详解，管程法与信号灯法！
Java实现生产者消费者案例
m0_61961937的博客
04-15 3752
Java实现生产者消费者案例
java多线程——生产者与消费者模型
L04593的博客
08-30 255
生产者与消费者 生产者与消费者模型 1.一个生产者一个消费者 步骤： 1.让生产者线程和消费者线程 共同操作同一个手机对象(资源) 2.让两个产品来回切换（目的是放大第一个步骤的问题）加锁，防止脏数据的出现 3.生产一个消费一个 代码实现： package com.dream.producer_consumer01_type01; public class Test01 { public static void main(String[] args) { Phone phone = new
Java多线程案例生产者消费者
01-20
然而Java又是解决并发的一把好手，下面简单介绍一下多线程案例的经典案例，生产者和消费者。 多线程通信图解 如何编写一个多线程配合的代码 线程操作资源类。定义一个资源类，并在资源类中完成相应的方法，将资源类...
java多线程生产者与消费者案例
11-18
关于java多线程的东西，里面有生产者与消费者的案例，感兴趣的朋友看一下吧。
Java多线程详解的全部案例
01-05
具体博文详见： ... 主要介绍java的多线程所有内容： 1. 线程的三种创建方法； 2. 线程的同步； 3. 生产者与消费者模型的解决 等等...... 注：本人使用的是IDEA！
生产者与消费者问题学习源码
11-10
在本文件中，可以逐步学习生产者与消费者问题的案例，并了解java多线程中的诸多问题
java 多线程并发实例
03-11
代码里面包含一个并发4个线程同时运行 全部开始 全部停止 单个停止还有点问题。 还有生产者消费者 里面的里面能帮助你理解多线程的运用！
多线程的同步问题的经典案例生产者-消费者模式剖析
唐欢
04-23 993
生产者－消费者问题（Producer-Consumer Problem）也称有限缓冲问题（Bounded-Buffer Problem），是一个多线程同步问题的经典案例。 生产者－消费者问题描述了两个访问共享缓冲区的线程，即生产者线程和消费者线程，在实际运行时会发生的问题。生产者线程的主要功能是生成一定量的数据放到缓冲区中，然后重复此过程。消费者线程的主要功能是从缓冲区提取（或消耗）数据。
Java经典例题生产者/消费者问题——适合初学者
qq_42951717的博客
01-24 1714
本文旨在介绍如何使用代码简单的解决生产者/消费者问题，涉及到的知识点只有多线程的创建和同步方法以及wait()和notify()方法，适合初学Java多线程的人，目的是为了帮助初学者更好的理解这个问题如何用代码实现，手把手的从问题分析到代码实践，希望对各位有所帮助
多线程生产消费模型的三种实现
heroking
09-07 147
1. synchornized实现 public class MyTest { private static String str = ""; private static final Object lock = new Object(); private static AtomicInteger num = new AtomicInteger(0); static...
Java实现生产者消费者问题
王梦杰_MengJie
04-26 4332
生产者-消费者问题是计算机科学中经典的同步问题之一，它描述了多个线程在共享数据的情况下如何协同工作。该问题通常涉及到一个共享缓冲区，其中生产者线程生成数据并将其放入缓冲区，而消费者线程从缓冲区中取出数据并对其进行处理。生产者和消费者线程必须协同工作，以避免竞态条件和死锁等问题。以上为通过Java代码实现解决生产消费者问题的实例，通过本实例希望大家能学会如果解决此问题，学会如何数据共享时，各个线程协同工作。
java多线程编程（综合案例：生产者与消费者）
CSDN博客
07-21 548
人如果要解决问题，首先要解决数据同步问题，如果要想解决数据同步问题最简单的就是使用同步代码块或同步方法，于是在这个时候对于同步的处理就可以直接在Message类中完成。到此，程序执行正常，生产消费一步一步进行，这种处理形式就是在进行多线程开发之中最原始的处理方案，整个等待、同步过程都是通过原生代码实现控制。如果现在想要解决生产者与消费者的问题，那么最好的解决方案就是使用等待唤醒机制，对于等待唤醒机制主要用到object类中的方法。解决完同步问题后，数据信息保持一致，但是不能避免数据重复问题。......
Java基础22 多线程之多生产者多消费者
Xs943的博客
03-11 1725
生产者消费者 包子案例 多个类（称为线程一类，线程二类） 需要一个共有的变量，即将这个变量封装为一个类（称为属性类）的属性，注意属性类的属性修饰符为public公共的，在测试类中new 这个属性类实例化为对象，然后将此对象作为参数传入需要的多个类（线程一，线程二）中，就可以实现共享对象的属性即变量，且多个类（线程一，线程二） 需要定义此对象（属性类）为私有变量，并提供有参构造 生产者线程和消费者线程要有共享对象，即将包子提升为类作为参数传入生产者线程和消费者线程，这个包子类就是共享的对象，就可以使用 syn
Java多线程（四）线程池使用方法
fox_bert的博客
08-18 8868
一、new Thread的弊端 执行一个异步任务你还只是如下new Thread吗？ new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 1、说说弊端： a. 每次new Threa...............
多线程 java 生产者消费者 200
最新发布
04-09
在Java中，可以使用多线程和相关的同步机制来实现生产者消费者模式。 在这种模式中，生产者负责生成数据，并将数据放入共享的缓冲区中，而消费者则从缓冲区中取出数据进行处理。为了保证线程安全和避免竞态条件，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值