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多线程实现

生产者和消费者问题是最经典的模拟多线程合作的问题之一,本文将提供一个具有多个生产者和多个消费者的Java实现。主要涉及到资源的锁定,多线程的合作,以及任务的抽象。 产品的抽象 每个产品都有一个唯一编号...

Java生产者消费者的五种实现方式

前言生产者和消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一个存储空间,生产者往存储空间中添加产品,消费者从存储空间中取走产品,当存储空间为空时,消费者阻塞,当存储空间满时,生产...

多线程经典案例——生产者/消费者问题的Java实现与详解

生产者消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个共...

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

用java实现生产者消费者模式,在全部代码之后会对重点、难点一一讲解! 以下是全部代码:class Demo7 { public static void main(String[] args...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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