java实现生产者与消费者

原创 2016年08月30日 12:17:56

写了一段生产者与消费者代码,有待改进

package test;

import java.util.Random;

//商品缓冲池
class Buffer {
    private int[] NumberPool = null;
    private int size;  //缓冲池大小
    private volatile int head = 0;
    private volatile int tail = 0;

    public Buffer(int count) {
        size = count + 1;
        NumberPool = count <= 0 ? new int[11] : new int[count + 1];
        for(int i=0;i<size;i++){
            NumberPool[i]=-1;
        }
    }

    public boolean isEmpty() {
        return head == tail ? true : false;
    }

    public boolean isFull() {
        return (tail + 1) % size == head ? true : false;
    }

    public void push(int product) {
        NumberPool[tail] = product;
        tail = (tail + 1) % size;
    }

    public int pull() {
        int number = NumberPool[head];
        head = (head + 1) % size;
        return number;
    }

    public int size() {

        return size == 0 ? 0 : size - 1;
    }

}

/**
 * 生产者与消费者
 * 可以有多个生产者与多个消费者
 * 只能有一个生产者对buffer进行操作
 * 只能有一个消费者对buffer进行操作
 * 一个生产者和一个消费者可以同时对buffer进行操作
 */
class ProduceAndConsum {
    private Buffer buffer;
    private Object plock = new Object(); // produce lock
    private Object clock = new Object(); // consume lock
    private Object nlock = new Object(); // notify lock

    public ProduceAndConsum(int bufferSize) {
        buffer = new Buffer(bufferSize);
    }

    public void Produce() throws InterruptedException{
        int product=new Random().nextInt(Integer.MAX_VALUE);
        synchronized (plock) {
            if (buffer.isFull()) {
                synchronized (nlock) {
                    System.out.println("buffer is full");
                    nlock.wait();//等待consum
                }
            } else {
                buffer.push(product);
                System.out.println(Thread.currentThread().getName()+"->push: " + product);
                synchronized (nlock) {
                   nlock.notifyAll(); //唤醒consum    
                }
            }
        }
    }

    public void Consum() throws InterruptedException {
        synchronized (clock) {
            if (buffer.isEmpty()) {
                synchronized (nlock) {
                    System.out.println("buffer is empty");
                    nlock.wait();//等待product
                }
            } else {
                System.out.println(Thread.currentThread().getName()+"->pull: " + buffer.pull());
                synchronized (nlock) {
                    nlock.notifyAll();  //唤醒product
                }
            }
        }
    }

}

public class test {
    public static void main(String[] args) {
        ProduceAndConsum pc = new ProduceAndConsum(100);
        Runnable produce=new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pc.Produce();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Runnable consum=new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pc.Consum();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread p1=new Thread(produce,"p1");
        Thread p2=new Thread(produce,"p2");
        Thread p3=new Thread(produce,"p3");

        Thread c1=new Thread(consum,"c1");
        Thread c2=new Thread(consum,"c2");
        Thread c3=new Thread(consum,"c3");
        Thread c4=new Thread(consum,"c4");
        Thread c5=new Thread(consum,"c5");
        Thread c6=new Thread(consum,"c6");
        Thread c7=new Thread(consum,"c7");
        Thread c8=new Thread(consum,"c8");

        p1.start();
        p2.start();
        p3.start();

        c1.start();
        c2.start();
        c3.start();
        c4.start();
        c5.start();
        c6.start();
        c7.start();
        c8.start();
    }
}

经典算法:生产者与消费者(JAVA实现)

public class ProducterAndConsumer { //也可以定义多个生产者和消费者 //但得用notifyAll()     public static void mai...
  • onlyKnowledge
  • onlyKnowledge
  • 2014年04月14日 03:25
  • 1061

Java 生产者 与 消费者 的实际运用

生产者与消费者模式的实际运用
  • qq1013598664
  • qq1013598664
  • 2016年10月08日 23:24
  • 795

使用Lock来实现生产者和消费者问题

Lock的await/singal 和 Object的wait/notify 的区别 在使用Lock之前,我们都使用Object 的wait和notify实现同步的。举例来说,一个producer和...
  • lingzhm
  • lingzhm
  • 2015年08月22日 21:54
  • 1773

Java并发之生产者-消费者几种实现

关于生产者-消费者Java实现,这里看到了一篇写的不错的文章,欢迎补充! 引用地址:http://blog.csdn.net/monkey_d_meng/article/details/625187...
  • zhuqiuhui
  • zhuqiuhui
  • 2016年08月01日 10:59
  • 1141

JAVA多线程(三)生产者消费者模式及实现方法

介绍了生产者消费者模式以及实现方法(wait¬ify,阻塞队列
  • antony9118
  • antony9118
  • 2016年05月23日 15:15
  • 2617

java模拟生产者与消费者问题(线程同步)

关于生产者与消费者的问题,百度百科上的定义是这样的:生产者消费者问题,也称有限缓冲问题,是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在...
  • hl17200178
  • hl17200178
  • 2016年10月04日 23:32
  • 1907

Java多线程-工具篇-BlockingQueue(实现生产者和消费者模式)

前言:      在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序...
  • li12412414
  • li12412414
  • 2017年01月17日 09:34
  • 1422

Java生产者与消费者(上)

本文来自http://blog.csdn.net/liuxian13183/ ,引用必须注明出处!         生产与消费者模式,是编程中最常用的模式之一,在多线程中应用比较明显。个人理解:在自助...
  • liuxian13183
  • liuxian13183
  • 2014年03月27日 21:45
  • 2255

Java多线程--生产者消费者模型(Semaphore实现)

需求要求:使用2个线程,分别代表:生产者、消费者。让他们并发的去生产、消费产品。生产的总数是不能超过N的。实现思路这里我们使用的是使用信号量去控制线程的生产消费,通过释放令牌的形式去控制生产者消费者的...
  • qq_24489717
  • qq_24489717
  • 2017年04月12日 21:53
  • 810

Java多线程-生产者消费者几种实现方式

http://blog.csdn.net/monkey_d_meng/article/details/6251879wait()/notify()方法http://blog.csdn.net/ghsa...
  • heqiangflytosky
  • heqiangflytosky
  • 2016年06月02日 16:53
  • 939
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java实现生产者与消费者
举报原因:
原因补充:

(最多只允许输入30个字)