0 0

java生产者消费者模式之2个生产者3

现在的需求,有2个生产者a和b,一个消费者c
每个轮回需要等待生产者a和b依次生产1个产品(该产品有id和value)后,通知消费者c取走queue中的2个product。
网上找的所有例子都是一个生产者,一个消费者的。。。自己做了一个代码。。。但是也只能1个生产者一个消费者,原因在addProduct里不知道怎么区分。。以及notifyAll的时候会在第一个生产者添加完product后,让第二个生产者也陷入等待。。
public class Consumer extends Thread {
    private ProductTable productTable;

    public Consumer(ProductTable productTable) {
        this.productTable = productTable;
    }

    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                // wait for a random time
                Thread.sleep((int) (Math.random() * 3000));
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            productTable.getProduct();
        }
    }
}


public class Producer extends Thread {
    private ProductTable productTable;
    private Product p;

    public Producer(ProductTable productTable, Product p) {
        this.productTable = productTable;
        this.p = p;
    }

    public void run() {
        for (int product = 1; product <= 10; product++) {
            productTable.addProduct(p);
        }
    }
}


public class Product {
    private int id;
    private String value;

    public Product(int it,String value){
        this.id=id;
        this.value=value;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}


public class ProductTable {
    private LinkedList products = new LinkedList();

    public synchronized void addProduct(Product product) {
        while(products.size() >= 2) { // 容量限制為 2
            try {
                wait();
            }
            catch(InterruptedException e) {}
        }

        products.addLast(product);
        System.out.println(product.getId()+" added");
        notifyAll();
    }

    public synchronized Product getProduct() {
        while(products.size() <= 0) {
            try {
                wait();
            }
            catch(InterruptedException e) {}
        }

        Product product = (Product) products.removeFirst();
        System.out.println(product.getId()+" removed");
        notifyAll();

        return product;
    }
}


public class Main {

    public static void main(String[] args) {
        Product a = new Product(1, "a");
        Product b = new Product(2, "b");
        ProductTable queue = new ProductTable();
        Producer producera = new Producer(queue, a);
        Consumer consumer = new Consumer(queue);
        new Thread(producera).start();
        new Thread(consumer).start();
    }
}

2008年11月25日 15:43

2个答案 按时间排序 按投票排序

0 0

public class Producer extends Thread {   
    private ProductTable productTable;   
    private Product p;   
  
    public Producer(ProductTable productTable, Product p) {   
        this.productTable = productTable;   
        this.p = p;   
    }   
  
    public void run() {   
         productTable.addProduct(p);   
    }   
}  


public class Consumer extends Thread {   
    private ProductTable productTable;   
  
    public Consumer(ProductTable productTable) {   
        this.productTable = productTable;   
    }   
  
    public void run() {   
           productTable.getProducts();          
    }   
}  


public class Main {   
  
    public static void main(String[] args) {   
        Product a = new Product(1, "a");   
        Product b = new Product(2, "b");   
        ProductTable queue = new ProductTable(); 
  
        for(int i=0; i<10; i++) {
             Producer producerA = new Producer(queue, a); 
             Producer producerB = new Producer(queue, b); 
             Consumer consumer = new Consumer(queue);   
             
             new Thread(producerA).start();
             new Thread(producerB).start();   
             new Thread(consumer).start();
   
    }   
}  

2008年12月02日 15:26
0 0

这是改后的代码,看下合符你的要求吗?


public class Product {   
    private int id;   
    private String value;   
  
    public Product(int it,String value){   
        this.id=id;   
        this.value=value;   
    }   
  
    public int getId() {   
        return id;   
    }   
  
    public void setId(int id) {   
        this.id = id;   
    }   
  
    public String getValue() {   
        return value;   
    }   
  
    public void setValue(String value) {   
        this.value = value;   
    }   
}  


public class ProductTable {   
    private LinkedList products = new LinkedList();   
  
    public synchronized void addProduct(Product product) {   
        while(products.size() >= 2) { // 容量限制為 2   
            try {   
                wait();   
            }   
            catch(InterruptedException e) {}   
        }   
  
        products.addLast(product);   
        System.out.println(product.getId()+" added");   
        notifyAll();   
    }   
  
   [color=blue] public synchronized Product[] getProducts() {   
        while(products.size() <= 0) {   
            try {   
                wait();   
            }   
            catch(InterruptedException e) {}   
        }   
 
        // remove two products every time
        Product[] products= new Product[2];
        products[0] = (Product) products.removeFirst();   
        System.out.println(products[0].getId()+" removed");  
        products[1]= (Product) products.removeFirst();
        System.out.println(products[1].getId()+" removed"); 

        // notify all the producers waiting for producing
        notifyAll();   
  
        return products;   
    }   [/color]}  

2008年12月02日 15:20

相关推荐

    Java 生产者消费者模式

    在Java编程中,生产者消费者模式是一种典型的多线程协作模型,用于解决系统资源供需不平衡的问题。这个模式的核心思想是将生产数据和消费数据的过程解耦,使得生产者可以独立地生产数据,而消费者可以独立地消费数据...

    java多线程实现生产者和消费者

    通过理解和掌握这些知识点,开发者能够有效地实现生产者-消费者模式,解决并发编程中的数据共享和协作问题。在实际项目中,这个模式常用于优化系统性能,尤其是在I/O密集型或计算密集型的应用中。

    java生产者消费者

    Java生产者消费者模式是一种多线程设计模式,它在并发编程中被广泛使用,用于解决资源的共享问题。在这个模式中,"生产者"负责创建数据,而"消费者"则负责处理这些数据。它们通过一个共享的数据缓冲区进行通信,避免...

    java实现生产者消费者

    在Java中,`java.util.concurrent`包下的`BlockingQueue`接口提供了一种线程安全的数据结构,非常适合用于实现生产者消费者模式。生产者将产品放入队列,消费者从队列中取出产品。`BlockingQueue`提供了`put()`和`...

    Java多线程 生产者-消费者模式

    生产者-消费者模式是一种经典的多线程设计模式,用于解决数据共享问题,尤其是在一个线程生产数据而另一个线程消费数据的情况下。在这个模式中,生产者负责生成数据并放入共享的数据结构(如队列),而消费者则从这...

    生产者消费者模式在java中的应用

    生产者消费者模式是一种经典的多线程同步问题解决方案,在Java中有着广泛的应用。它主要用于解决系统中数据处理的并发问题,确保生产者线程与消费者线程之间的协作与数据的有序处理。这种模式遵循一个基本原理:生产...

    java 多线程 生产者消费者模式

    Java多线程编程是开发高并发、高性能应用的关键技术之一,而生产者消费者模式是多线程编程中常用的一种设计模式。它通过分离数据的生产和消费过程,实现了线程间的协同工作,有效避免了资源的竞争和浪费。在这个模式...

    java生产者消费者demo

    在这个"java生产者消费者demo"中,开发者使用了适配器模式来构建解决方案。适配器模式是一种设计模式,它允许不同接口的类协同工作,即使它们原本无法直接交互。在生产者消费者问题中,适配器模式可能被用来协调生产...

    Java 生产消费者模式

    Java生产消费者模式是一种经典的并发设计模式,用于解决多个线程之间的协作问题。在这个模式中,生产者负责生成数据,而消费者则负责消费这些数据。它基于“缓冲区”概念,即一个有限大小的数据存储区域,生产者将...

    java 生产者消费者问题(源码)

    Java生产者消费者问题是多线程编程中的一个经典案例,它主要展示了如何通过共享资源来实现线程间的协作。这个问题源于现实生活中的生产流水线,其中生产者负责制造产品,而消费者负责消耗这些产品。在计算机系统中,...

    多线程简易实现生产者消费者模式

    在提供的文件"stack"中,可能包含了一个使用栈作为缓冲区的生产者消费者模式实现。栈具有后进先出(LIFO)的特性,适合作为简单的缓冲区。具体实现可能包括了`Stack`类,用于表示栈,并包含了生产和消费的方法,以及...

    Java生产者与消费者

    以上就是Java中实现生产者与消费者模式的基本步骤。这个模式通过合理地分配资源,避免了生产者过度生产导致的浪费,同时也防止了消费者在无数据可消费时的空耗。此外,还可以通过扩展线程数量,实现更复杂的并发处理...

    java 多线程 生产者消费者模式源码

    java 多线程 生产者消费者模式,多个生产者对多个消费者,使用jdk 线程池及 BlockingQueue实现,解决了待生产的任务生产完成后,正常终止所有线程,避免线程(特别是消费者线程)因阻塞而无限等待的情况。源码中还简单...

    java生产者消费者模型

    Java生产者消费者模型是多线程编程中一种经典的并发控制模型,它源于操作系统中的哲学思想,用于解决资源的共享和异步处理问题。在该模型中,"生产者"线程负责生成数据,而"消费者"线程则负责消费这些数据。两者之间...

    java生产者与消费者实验报告

    ### Java生产者与消费者模型详解 #### 实验背景与目的 在并发编程中,生产者-消费者模式是一种经典的解决同步问题的设计模式。本实验旨在通过实际编程操作,深入理解Java中生产者与消费者模型的工作机制及其同步...

    界面话模拟生产者消费者模式java

    在"界面话模拟生产者消费者模式java"的项目中,开发者创建了一个用户界面,允许用户自定义生产者生产数据的数量、消费者消费数据的数量,以及仓库(缓冲区)的最大容量、最小剩余量,还有生产者每次生产的数据量和...

    生产者和消费者模式多线程

    创建一个简单的生产者消费者模型,可以使用以下伪代码: ```java class Producer implements Runnable { private final BlockingQueue&lt;String&gt; queue; public Producer(BlockingQueue&lt;String&gt; queue) { this....

    java生产者消费者模式

    在Java中,有多种实现生产者消费者模式的方法,主要包括: 1. **wait() / notify()方法**:这是基于Object类中的两个方法,适用于任何对象。生产者或消费者在需要等待时调用wait(),释放锁并进入等待状态;当条件...

    Java JDK1.5 生产消费者模式解决方案

    在Java编程语言中,生产者消费者模式是一种经典的多线程设计模式,用于处理并发问题。在JDK 1.5及以后的版本中,Java引入了`java.util.concurrent`包,其中包含了一些强大的并发工具类,如`Lock`接口和`Condition`...

    生产者消费者java源码

    在Java中,`BlockingQueue`接口是实现生产者消费者模式的关键组件。它提供了一种线程安全的数据结构,允许线程在尝试插入或删除元素时自动进行阻塞,直到操作可以执行。例如,`ArrayBlockingQueue`或`...

Global site tag (gtag.js) - Google Analytics