手贱瞎写不要看:生产者消费者-同步问题

  1 package ThreadL;
  2
  3 import java.util.LinkedList;
  4
  5 class Queue extends LinkedList<String>{
  6     int lenght;
  7     public Queue(){
  8
  9     }
 10
 11     public Queue(int length){
 12         this.lenght = length;
 13     }
 14
 15     public int getLength(){
 16         return this.lenght;
 17     }
 18
 19     public String shift(){
 20         if(!this.isEmpty()){
 21             return this.remove();
 22         }else{
 23             return "空了";
 24         }
 25     }
 26
 27     public void push(String ch){
 28         if(this.size()<=this.lenght){
 29             this.addLast(ch);
 30         }
 31     }
 32
 33     public boolean isFull(){
 34         if(this.size() == this.lenght){
 35             return true;
 36         }else{
 37             return false;
 38         }
 39     }
 40 }
 41 class Depot{
 42     Queue queue = null;
 43     public Depot(int length){
 44         this.queue = new Queue(length);
 45     }
 46     static int i = 1;
 47     public synchronized void produce(String ch){
 48         this.notify();
 49         while(this.queue.isFull()){
 50             try {
 51                 this.wait();
 52             } catch (InterruptedException e) {
 53                 e.printStackTrace();
 54             }
 55         }
 56         this.queue.push(ch);
 57         System.out.println("生产第\t" + (i++) + "\t个产品\t" + this.queue.getLast());
 58     }
 59     public synchronized void consume(){
 60         this.notify();
 61         while(this.queue.isEmpty()){
 62             try {
 63                 this.wait();
 64             } catch (InterruptedException e) {
 65                 e.printStackTrace();
 66             }
 67         }
 68         System.out.println("消耗掉第\t" + (--i) + "\t个产品\t" + this.queue.getFirst());
 69         this.queue.shift();
 70     }
 71 }
 72 class Produce implements Runnable{
 73     Depot depot;
 74     public Produce(Depot depot){
 75         this.depot=depot;
 76     }
 77     public void run(){
 78         for(int i=0;i<10;i++){
 79             this.depot.produce("A");
 80         }
 81     }
 82 }
 83 class Consume implements Runnable{
 84     Depot depot;
 85     public Consume(Depot depot){
 86         this.depot= depot;
 87     }
 88     public void run(){
 89         for(int i=0;i<10;i++){
 90             this.depot.consume();
 91         }
 92     }
 93 }
 94 public class Thread10 {
 95     public static void main(String[] args){
 96         Depot depot = new Depot(8);
 97         Thread pro = new Thread(new Produce(depot));
 98         Thread con = new Thread(new Consume(depot));
 99         pro.start();
100         pro.setName("PRO");
101         con.start();
102         con.setName("CON");
103     }
104 }
时间: 2024-10-16 04:57:27

手贱瞎写不要看:生产者消费者-同步问题的相关文章

生产者消费者 &amp; 读者写者

生产者消费者 对于生产者消费者这个问题,我们可以用生活中一个简单的例子来说明: 桌子上有个盘子,一个人往盘子里面放苹果,一个人从盘子里面拿走苹果,放苹果的人相当于生产者,拿走苹果的人相当于消费者,而盘子就相当于一个生产场所.如果我们要保证拿苹果的人一直都有苹果拿,那就要让放苹果的人一直放,而且要比拿苹果的人快一点.当盘子满的时候放苹果的人就要等着拿苹果的人把苹果拿走,等盘子里有了位置,就可以继续放苹果.如果我们要求每次只能放一个苹果,拿苹果的人每次也只能拿一个苹果,而放苹果和拿苹果的人都不只是一

多线程生产者消费者模式

闲着没事,写了个生产者消费者模式玩玩,顺便熟悉下notify的用法. package sync; public class Test { public static void main(String[] args) { Test test = new Test(); Producer producer = test.new Producer(); producer.start(); Consumer consumer = test.new Consumer(); consumer.setName

Java实现生产者消费者问题与读者写者问题

摘要: Java实现生产者消费者问题与读者写者问题 1.生产者消费者问题 生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从仓库中取走产品.解决生产者/消费者问题的方法可分为两类:(1)采用某种机制保护生产者和消费者之间的同步:(2)在生产者和消费者之间建立一个管道.第一种方式有较高的效率,并且易于实现,代码的可控制性较好,属于常用的模式.第二种管道缓冲区不易控制,被传输数据对象不易于封装等,实用性不强. 同步问题核心在

利用生产者消费者模型和MQ模型写一个自己的日志系统-并发设计里一定会用到的手段

一:前言 写这个程序主要是用来理解生产者消费者模型,以及通过这个Demo来理解Redis的单线程取原子任务是怎么实现的和巩固一下并发相关的知识:这个虽然是个Demo,但是只要稍加改下Appender部分也是可以用于项目中的,假设项目里确实不需要log4j/logback之类的日志组件的时候: 二:实现方式 1.利用LinkedList作为MQ(还可以用jdk自带的LinkedBlockingQueue,不过这个Demo主要是为了更好的理解原理因此写的比较底层): 2.利用一个Daemon线程作为

‘生产者-消费者’模型与‘读-写者’模型

★生产者-消费者模型 首先,我们先分析一下生产者与消费者模型:生产者与消费者是模型中不可缺少的2种角色,当然模型中肯定需要一个保存数据的场所,能够将生产者生产的数据进行存储.同时,模型必须要满足生产者产生出数据后,消费者才能够进行使用,即就是消费者必须位于生产者之后,当然生产者生产的数据最多将场所放置满就不能继续生产,下面有简单的图示: 当然,如果有多个消费者和多个生产者,生产者与消费者之间的关系是同步的,生产者与生产者之间是互斥的,因为一块空间不能让多个生产者同时进行生产.消费者和消费者之间也

读者与写者、生产者与消费者

1.读者写者 写者:写数据 读者:仅仅是读数据,不存在取走数据 写者与写者关系:互斥 读者与读者关系:没有关系 写者与读者关系:同步.互斥 解决方法: 1)读者优先:读者正在读,写者不能终止读者,直到读者读完,写者才能写入 2)写者优先:写者正在写,读者不能终止写者,直到写者写完,读者才能写入 2.生产者消费者 生产者:产生数据 消费者:取走数据 生产者与生产者:互斥关系 消费者与消费者:互斥关系 生产者与消费者:互斥.同步关系 生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程.与

用yield写协程实现生产者消费者

思路: yield可以使得函数阻塞,next,和send可以解阻塞,实现数据不竞争的生产者消费者模式 代码: import random #随机数,模拟生产者的制造物 def eat(): #消费者 while True: item = (yield) print("消费了:",item) def pro(g): #生产者 next(g) while True: item = random.randint(0,99) print("生产了:",item) g.sen

生产者消费者模式(转)

本文转载自博文系列架构设计:生产者/消费者模式.文中对原文格式进行了稍加整理. 概述 今天打算来介绍一下“生产者/消费者模式”,这玩意儿在很多开发领域都能派上用场.由于该模式很重要,打算分几个帖子来介绍.今天这个帖子先来扫盲一把.如果你对这个模式已经比较了解,请跳过本扫盲帖,直接看下一个帖子(关于该模式的具体应用) . 看到这里,可能有同学心中犯嘀咕了:在四人帮(GOF)的23种模式里面似乎没听说过这种嘛!其实GOF那经典的23种模式主要是基于OO的(从书名<Design Patterns: E

从生产者消费者窥探线程同步(上)

欢迎转载,转载请注明出处.尊重他人的一丢丢努力,谢谢啦! 阅读本篇之后,如果你觉得说得还有点道理,那不妨先戳一下从生产者消费者窥探线程同步(下) ,两篇一起嚼才更好呢. 最近复习了下生产者消费者模式,虽然对它不太陌生,但要说认认真真地实现,还真从来没有过,这里将它总结一下,有不妥或者见识不到之处,欢迎留言指出. 为什么要使用 大概基于以下2点: (1)可以实现解耦 大多数设计模式,都会创造出一个第三者来担任解耦角色.比如末班模式的模板类,工厂模式的工厂类等.而消费者观察者模式则是使用拥塞队列来给