Java并发编程 生产者消费者模式

这是java开发时常用到的模式，可以使程序在设计时分开生产者和消费者之间的相互调用。

 

模式中需要建立三个对象：生产者  消费者  仓库

生产者：把生产出来的产品放到仓库总

消费者：从仓库中取出产品进行消费

仓库：采用同步方法，对仓库上锁同步，每次只能有一个对象对其进行操作

类图如下：

类图如下：

 

 

 

仓库类代码：使用队列的方式实现

package consumer;

import java.util.concurrent.ArrayBlockingQueue;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class ServerAlarmQueue {
 private static int MAX_SIZE = 1000;
 private static  Logger logger = LoggerFactory.getLogger(ServerAlarmQueue.class);
 private static ArrayBlockingQueue<Object> alramQueue=null;
 public ServerAlarmQueue(int capacity) {
  super();
  MAX_SIZE = capacity;
  alramQueue = new ArrayBlockingQueue<Object>(capacity);
 }
 
 public ServerAlarmQueue() {
  super();
  alramQueue = new ArrayBlockingQueue<Object>(MAX_SIZE);
 }
 
 /**
  * 从队列终获取一个对象
  * 
  * @return
  */
 public synchronized Object consume() {
  Object object = null;
  while (getQueueSize() == 0) {
   try {
    wait();
    logger.debug("队列已空，消费等待...");
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  object = alramQueue.poll();
  System.out.println(Thread.currentThread().getName()+"消费产品："+object.toString());
  this.notifyAll();
  return object;
 }
 
 /**
  * 向对另种插入一个对象
  * 
  * @param object
  * @return
  */
 public synchronized boolean produce(Object object) {
  boolean flag = false;
  while (getQueueSize() == MAX_SIZE) {
   try {
    wait();
    logger.debug("队列已满，生产等待....");
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  flag = alramQueue.offer(object);
  System.out.println(Thread.currentThread().getName()+"生产出产品："+object.toString());
  this.notifyAll();
  return flag;
 }
 
 public int getQueueSize() {
  return alramQueue.size();
 }
 
 public void clear() {
  alramQueue.clear();
 }
 
}

 

消费者：

package consumer;

public class Consumer implements Runnable {
	private ServerAlarmQueue serverAlarmQueue = null;
	private boolean isStart = true;
	
	public Consumer(ServerAlarmQueue serverAlarmQueue) {
		super();
		this.serverAlarmQueue = serverAlarmQueue;
	}
	
	@Override
	public void run() {
		while (isStart) {
			getProducts();
			try {
				
				// 等待30毫秒
				Thread.sleep(30);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	private void getProducts() {
		Object obj = serverAlarmQueue.consume();
		System.out.println(obj);
	}
	
	public void stop() {
		isStart = false;
	}
}

 

生产者：

package com.consume;

public class Producer implements Runnable{
private  ServerAlarmQueue serverAlarmQueue=null;


	public Producer(ServerAlarmQueue serverAlarmQueue) {
	super();
	this.serverAlarmQueue = serverAlarmQueue;
}


	@Override
  public void run() {
		char c;

		for (int i = 0; i < 200; i++) {

			// 随机生成大写字母字符
			c = (char) (Math.random() * 26 + 'A');
			produce(c);
			
		try {
			
							// 等待30毫秒
							Thread.sleep(30);
						} catch (Exception e) {
							e.printStackTrace();
						}
		}
		
  }
	
	private void produce(Object obj){
		serverAlarmQueue.produce(obj);
	}
}

 

测试代码

package com.consume;

public class ThreadMain {
	
	public static void main(String[] args) {
		// 1.准备堆栈数据结构
		ServerAlarmQueue stack = new ServerAlarmQueue();
		
		// 2.准备生产者线程
		Producer producer1 = new Producer(stack);
		Thread t1 = new Thread(producer1);
		t1.setName("1号生产者");
		
		Producer producer2 = new Producer(stack);
		Thread t2 = new Thread(producer2);
		t2.setName("2号生产者");
		
		// 3.准备消费者线程
		Consumer consumer1 = new Consumer(stack);
		Thread t3 = new Thread(consumer1);
		t3.setName("1号消费者");
		
		Consumer consumer2 = new Consumer(stack);
		Thread t4 = new Thread(consumer2);
		t4.setName("2号消费者");
		
		
		t3.start();
		t4.start();
		
		t1.start();
		t2.start();
	}
}