生产者和消费者问题(四)下

简介: 生产者和消费者问题(四)

五. 仓库版 生产者和消费者 第四版


五.一 产品 Info 类


Info 就不需要进行等待和唤醒了。


public class Info {
    private String name;
    private String content;
    public Info(){
    }
    public synchronized  void setInfo(String name,String content){
        this.setName(name);
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setContent(content);
    }
    public synchronized  void getInfo(){
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getName()+"---->"+this.getContent());
    }
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContent() {
        return this.content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    public String toString() {
        return "Info{" +
                "name='" + name + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}


五.二 仓库 Storage


public class Storage {
    private static final int DEFAULT_SIZE=10;
    //定义一个集合,用于存储对象信息。
    private volatile List<Info> infoList=new ArrayList<Info>();
    private  volatile int count=0;
    /**
     * 进行生产
     */
    public  void produce(Info info){
       synchronized (infoList) {
            //超过出容易
            if(infoList.size()>=DEFAULT_SIZE){
                System.out.println("生产者:"+Thread.currentThread().getName()+"的物品不能放置进来,因为仓库已经满了,");
                try {
                    infoList.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println();
           count++;
            System.out.println("生产者:"+Thread.currentThread().getName()+"生产了一件产品:"
            +info.toString()+",已经放置在仓库了,仓库有:"+count+"件商品");
            infoList.add(info);
            infoList.notifyAll();
        }
    }
    /**
     *
     */
    public synchronized  Info consume(){
        synchronized (infoList){
            //为 0了
            if(infoList.size()<=0){
                System.out.println("消费者:"+Thread.currentThread().getName()+"不能消费产品,因为仓库已经空了.");
                 try{
                     infoList.wait();
                 }catch(InterruptedException e){
                     e.printStackTrace();
                 }
            }
            Info lastInfo=infoList.get(count-1);
            infoList.remove(count-1);
            count--;
            System.out.println("消费者:"+Thread.currentThread().getName()+"消费了一件产品:"+lastInfo.toString()
            +",还剩下"+count+"件产品");
            //通知
            infoList.notifyAll();
            return lastInfo;
        }
    }
    //public static List<Info> getInfoList() {
     //   return infoList;
   // }
}


五.三 生产者 Productor


public class Productor implements  Runnable {
    private Storage storage;
    private boolean isFirst=true;
    //传入仓库
    public Productor(Storage storage){
        this.storage=storage;
    }
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            //定义产品
            Info info=new Info();
           System.out.println("生产者运行i:"+i);
            if(isFirst){  //是第一个,那么就生产第一个消息
                info.setInfo("两个蝴蝶飞","这是两个蝴蝶飞");
                isFirst=false;
            }else{
                info.setInfo("老蝴蝶","这是老蝴蝶");
                isFirst=true;
            }
            //放置到仓库里面
            storage.produce(info);
        }
    }
}


五.四 消费者 Consumer


public class Consumer implements Runnable {
    private Storage storage;
    public Consumer(Storage storage){
        this.storage=storage;
    }
    @Override
    public void run() {
        for(int i=0;i<50;i++){
           System.out.println("消费者运行i:"+i);
            //获取信息
            Info info=storage.consume();
            //info.getInfo();
        }
    }
}


五.五 主程序测试 Demo


public class Demo {
    public static void main(String[] args) {
        //定义生产者
        Storage storage=new Storage();
        //生产
        Productor productor=new Productor(storage);
        //消费
        Consumer consumer=new Consumer(storage);
        Thread thread=new Thread(productor);
        Thread thread1=new Thread(productor);
        Thread thread2=new Thread(consumer);
        Thread thread3=new Thread(consumer);
        //启动
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}


五.六 测试运行,发现问题


20200619190146229.png


发现会生产一件,消费一件, 这是两个生产者和两个消费者。


如果是三个生产者和一个消费者呢?


public class Demo {
    public static void main(String[] args) {
        //定义生产者
        Storage storage=new Storage();
        //生产
        Productor productor=new Productor(storage);
        //消费
        Consumer consumer=new Consumer(storage);
        Thread thread=new Thread(productor);
        Thread thread1=new Thread(productor);
        Thread thread2=new Thread(consumer);
        Thread thread3=new Thread(consumer);
        //启动
        thread.start();
        thread1.start();
        new Thread(productor).start();
        thread2.start();
       // thread3.start();
    }
}


运行程序,查看


20200619190152374.png


仓库满了之后,就不能再继续生产产品了。


如果一个生产者,三个消费者呢?


public class Demo {
    public static void main(String[] args) {
        //定义生产者
        Storage storage=new Storage();
        //生产
        Productor productor=new Productor(storage);
        //消费
        Consumer consumer=new Consumer(storage);
        Thread thread=new Thread(productor);
        Thread thread1=new Thread(productor);
        Thread thread2=new Thread(consumer);
        Thread thread3=new Thread(consumer);
        //启动
        thread.start();
       // thread1.start();
        thread2.start();
        thread3.start();
        new Thread(consumer).start();
    }
}


运行程序,


20200619190158386.png


消费者不能取出了,会等待,等待生产者往仓库里面放置产品。


生产者和消费者的问题特别重要,一定要掌握。


谢谢您的观看,如果喜欢,请关注我,再次感谢 !!!

相关文章
|
4月前
|
Java
并发编程之生产者和消费者问题
该博客文章通过Java代码示例介绍了生产者和消费者问题的线程间通信解决方案,演示了如何使用synchronized关键字和wait/notifyAll方法来实现线程间的同步和资源的协调访问。
|
4月前
|
安全
LinkedBlockingQueue实现的生产者和消费者模型
LinkedBlockingQueue实现的生产者和消费者模型
38 1
|
4月前
|
设计模式 安全 Python
生产者与消费者模式
生产者与消费者模式
|
7月前
|
消息中间件 RocketMQ
RocketMq消费者/生产者配置
RocketMq消费者/生产者配置
|
7月前
|
负载均衡 Java API
SpringCloud深入理解 | 生产者、消费者
SpringCloud深入理解 | 生产者、消费者
141 0
|
安全 数据处理
线程中的生产者和消费者模式
线程中的生产者和消费者模式
130 0
线程中的生产者和消费者模式
|
设计模式 安全
生产者与消费者模型
生产者与消费者模型
106 0
生产者与消费者模型
|
前端开发 Java Nacos
服务生产者 | 学习笔记
快速学习服务生产者。
服务生产者 | 学习笔记
2.6操作系统(生产者消费问题 多生产者—消费者问题 吸烟者问题)
1.生产者消费问题 能否改变相邻P、V操作的顺序? 2.多生产者—消费者问题 如何实现? 可不可以不用互斥信号量? 如果盘子(缓冲区)容量为2 知识回顾与重要考点 3.吸烟者问题 如何实现
2.6操作系统(生产者消费问题 多生产者—消费者问题 吸烟者问题)
|
消息中间件 存储 SQL
MQ系列6:消息的消费
MQ系列6:消息的消费
284 0
MQ系列6:消息的消费

热门文章

最新文章