java生产者消费者模型

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

public class Consumer extends Thread {
    private String product;
    private Queue<String> storeHouse = new LinkedBlockingQueue<String>();
    
    public Consumer(){
        
    }
    
    public Consumer(Queue<String>  storeHouse){
        this.storeHouse = storeHouse;
    }

public void consume(){
        while (true) {
            synchronized (storeHouse) {
                    try {
                    while (storeHouse.isEmpty()) {
                        System.out.println("storeHouse is empty , please wait");
                        storeHouse.wait();
                        }
                }catch (InterruptedException ie){
                    
                }
            }
            product = storeHouse.poll();
            System.out.println("Consume :"+product);
        }
    }
    
    public void run() {
        consume();
    }
    
}

import java.util.Queue;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;

public class Producer extends Thread {
    private String product;
    private Queue<String> storeHouse = new LinkedBlockingQueue<String>();
    
    public Producer(){
        
    }
    
    public Producer(Queue<String>  storeHouse){
        this.storeHouse = storeHouse;
    }
    
    public String getProduct() {
        return product;
    }

public void setProduct(String product) {
        this.product = product;
    }

@Override
    public void run(){
        produce();
    }
    
    public void produce(){
        while (true) {
            synchronized (storeHouse) {
                setProduct(getRandomString(5)) ;
                storeHouse.add(product);
                System.out.println("Produce : "+getProduct());
                try {
                    storeHouse.notifyAll();
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    return ;
                }
            }
        }
    }
    
    public static String getRandomString(int length){  
        String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";  
        Random random = new Random();  
        StringBuffer stringBuffer = new StringBuffer();  
          
        for(int i = 0 ; i < length; ++i){  
            int number = random.nextInt(62);//[0,62)  
              
            stringBuffer.append(str.charAt(number));  
        }  
        return stringBuffer.toString();  
    }
    
}

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumer {
    
    private int MAX = 10;

public ProducerConsumer() {
    }
    
    public static void main(String[] args) {
        Queue<String> storeHouse = new LinkedBlockingQueue<String>();
        Producer producer1 = new Producer(storeHouse);
        Producer producer2 = new Producer(storeHouse);
        Producer producer3 = new Producer(storeHouse);
        Consumer comsumer1 = new Consumer(storeHouse);
        Consumer comsumer2 = new Consumer(storeHouse);
        Consumer comsumer3 = new Consumer(storeHouse);
        Consumer comsumer4 = new Consumer(storeHouse);
        Thread p1 = new Thread(producer1);
        Thread p2 = new Thread(producer2);
        Thread p3 = new Thread(producer3);
        Thread c1 = new Thread(comsumer1);
        Thread c2 = new Thread(comsumer2);
        Thread c3 = new Thread(comsumer3);
        Thread c4 = new Thread(comsumer4);
        p1.start();
        p2.start();
        p3.start();
        c1.start();
        c2.start();
        c3.start();
        c4.start();
   }
}

java生产者消费者模型,布布扣,bubuko.com

时间: 2024-12-28 12:31:43

java生产者消费者模型的相关文章

Java多线程之~~~~使用wait和notify实现生产者消费者模型

在多线程开发中,最经典的一个模型就是生产者消费者模型,他们有一个缓冲区,缓冲区有最大限制,当缓冲区满 的时候,生产者是不能将产品放入到缓冲区里面的,当然,当缓冲区是空的时候,消费者也不能从中拿出来产品,这就 涉及到了在多线程中的条件判断,java为了实现这些功能,提供了wait和notify方法,他们可以在线程不满足要求的时候 让线程让出来资源等待,当有资源的时候再notify他们让他们继续工作,下面我们用实际的代码来展示如何使用wait和 notify来实现生产者消费者这个经典的模型. 首先是

Java里的生产者-消费者模型(Producer and Consumer Pattern in Java)

生产者-消费者模型是多线程问题里面的经典问题,也是面试的常见问题.有如下几个常见的实现方法: 1. wait()/notify() 2. lock & condition 3. BlockingQueue 下面来逐一分析. 1. wait()/notify() 第一种实现,利用根类Object的两个方法wait()/notify(),来停止或者唤醒线程的执行:这也是最原始的实现. 1 public class WaitNotifyBroker<T> implements Broker&

Java多线程15:Queue、BlockingQueue以及利用BlockingQueue实现生产者/消费者模型

Queue是什么 队列,是一种数据结构.除了优先级队列和LIFO队列外,队列都是以FIFO(先进先出)的方式对各个元素进行排序的.无论使用哪种排序方式,队列的头都是调用remove()或poll()移除元素的.在FIFO队列中,所有新元素都插入队列的末尾. Queue中的方法 Queue中的方法不难理解,6个,每2对是一个也就是总共3对.看一下JDK API就知道了: 注意一点就好,Queue通常不允许插入Null,尽管某些实现(比如LinkedList)是允许的,但是也不建议. Blockin

生产者消费者模型java

马士兵老师的生产者消费者模型,我感觉理解了生产者消费者模型,基本懂了一半多线程. public class ProducerConsumer { public static void main(String[] args) { SyncStack ss = new SyncStack(); Producer p = new Producer(ss); Consumer c = new Consumer(ss); new Thread(p).start(); new Thread(c).start

Java线程:并发协作-生产者消费者模型

对于多线程程序来说,不管任何编程语言,生产者消费者模型都是最经典的. 实际上,准确的说应该是"生产者-消费者-仓储"模型,离开了仓储,生产者消费者模型就显得没有说服力了. 对于此模型,应该明确以下几点: 生产者仅仅在仓储未满时候生产,仓满则停止生产. 消费者仅仅在仓储有产品时候才能消费,仓空则等待. 当消费者发现仓储没有产品的时候会通知生产者生产. 生产者在生产出可消费产品时候,应该通知消费者去消费. 此模型将要结合java.lang.Object的wait与notify,notify

[Java并发编程实战] 阻塞队列 BlockingQueue(含代码,生产者-消费者模型)

见贤思齐焉,见不贤而内自省也.-<论语> PS: 如果觉得本文有用的话,请帮忙点赞,留言评论支持一下哦,您的支持是我最大的动力!谢谢啦~ Java5.0 增加了两种新的容器类型,它们是指:Queue 和 BlockingQueue.Queue 用来临时保存一组等待处理的元素.BlockingQueue 扩张了 Queue 接口,增加了可阻塞的插入和获取等操作. BlockingQueue 通常运用于一个线程生产对象放入队列,另一个线程从队列获取对象并消费,这是典型的生产者消费者模型. 这里写图

生产者消费者模型Java实现

生产者消费者模型 生产者消费者模型可以描述为: ①生产者持续生产,直到仓库放满产品,则停止生产进入等待状态:仓库不满后继续生产: ②消费者持续消费,直到仓库空,则停止消费进入等待状态:仓库不空后,继续消费: ③生产者可以有多个,消费者也可以有多个: 生产者消费者模型 对应到程序中,仓库对应缓冲区,可以使用队列来作为缓冲区,并且这个队列应该是有界的,即最大容量是固定的:进入等待状态,则表示要阻塞当前线程,直到某一条件满足,再进行唤醒. 常见的实现方式主要有以下几种. ①使用wait()和notif

Java多线程14:生产者/消费者模型

什么是生产者/消费者模型 一种重要的模型,基于等待/通知机制.生产者/消费者模型描述的是有一块缓冲区作为仓库,生产者可将产品放入仓库,消费者可以从仓库中取出产品,生产者/消费者模型关注的是以下几个点: 1.生产者生产的时候消费者不能消费 2.消费者消费的时候生产者不能生产 3.缓冲区空时消费者不能消费 4.缓冲区满时生产者不能生产 生产者/模型作为一种重要的模型,它的优点在于: 1.解耦.因为多了一个缓冲区,所以生产者和消费者并不直接相互调用,这一点很容易想到,这样生产者和消费者的代码发生变化,

Java多线程(十):BlockingQueue实现生产者消费者模型

BlockingQueue BlockingQueue.解决了多线程中,如何高效安全"传输"数据的问题.程序员无需关心什么时候阻塞线程,什么时候唤醒线程,该唤醒哪个线程. 方法介绍 BlockingQueue是Queue的子类 void put(E e) 插入指定元素,当BlockingQueue为满,则线程阻塞,进入Waiting状态,直到BlockingQueue有空闲空间再继续. 这里以ArrayBlockingQueue为例进行分析 void take() 队首出队,当Bloc