java多线程 生产者-消费者

 

 

对于此模型，应该明确一下几点：
1、生产者仅仅在仓储未满时候生产，仓满则停止生产。
2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。
3、当消费者发现仓储没产品可消费时候会通知生产者生产。
4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。 

 

要消费的实体 : Message

   

/**
 * @ClassName: Message
 * @Description: "生产者-消费者"模型中要消费的实体
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Message {

	public static int messageId;
	private String content;
	
	/**
	 * @return 返回 messageId
	 */
	public static int getMessageId() {
		return messageId;
	}
	/**
	 * @param 对messageId进行赋值
	 */
	public static void setMessageId(int messageId) {
		Message.messageId = messageId;
	}
	/**
	 * @return 返回 content
	 */
	public String getContent() {
		return content;
	}
	/**
	 * @param 对content进行赋值
	 */
	public void setContent(String content) {
		this.content = content;
	}
}

 

消费者 ： Consumer

   

/**
 * @ClassName: Consumer
 * @Description: 消费者
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Consumer implements Runnable {

	//消息队列
	private MessageQueue queue;

	/**
	 * <p>Title: Consumer</p>
	 * <p>Description: 构造方法</p>
	 * @param queue
	 */
	public Consumer(MessageQueue queue) {
		this.queue = queue;
	}

	/**
	 * <p>Title: run</p>
	 * <p>Description: 执行线程</p>
	 * @see java.lang.Thread#run()
	 * @author 
	 */
	public void run() {

		while (true) {
			//消费
			queue.consume();
			
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

 

生产者: Producer

   

/**
 * @ClassName: Producer
 * @Description: 生产者
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Producer implements Runnable {

	//消息队列
	private MessageQueue queue;
	
	/**
	 * <p>Title: Producer</p>
	 * <p>Description: 构造方法</p>
	 * @param queue
	 */
	public Producer(MessageQueue queue){
		this.queue = queue;
	}
	
	/**
	 * <p>Title: run</p>
	 * <p>Description: 执行线程</p>
	 * @see java.lang.Thread#run()
	 * @author 
	 */
	@SuppressWarnings("static-access")
	public void run(){
		
		//要生产的实体
		Message message = null;
		
		while (true){
			
			message = new Message();
			
			message.setMessageId(++Message.messageId);
			message.setContent("food"+Message.messageId);
			
			//生产
			queue.produce(message);
			
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

消息队列 : MessageQueue

   

/**
 * @ClassName: MessageQueue
 * @Description: 消息队列
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class MessageQueue {

	private static Logger log = Logger.getLogger(MessageQueue.class);

	// 队列
	List<Message> queue = new ArrayList<Message>(10);

	/** 队列中message对象的最大值,默认为500 */
	int maxMessageNum = 500;

	/**
	 * @Title: produce
	 * @Description: 生产
	 * @param message
	 *            要生产的实体
	 * @author 
	 */
	public synchronized void produce(Message message) {

		try {
			while (queue.size() == maxMessageNum) {

				log.info(Thread.currentThread().getName() + ",队列满,等待中...");

				this.wait();
			}
		} catch (InterruptedException e) {
			log.error("wait() exception.", e);
		}

		queue.add(message);

		log.info(Thread.currentThread().getName() + ",正在生产"
				+ message.getContent() + ",当前个数:" + getCount());

		notifyAll();
	}

	/**
	 * @Title: consume
	 * @Description: 消费
	 * @param message
	 *            要消费的实体
	 * @author 
	 */
	public synchronized void consume() {

		try {
			while (queue.size() == 0) {

				log.info(Thread.currentThread().getName() + ",队列空,等待中...");

				this.wait();
			}
		} catch (InterruptedException e) {
			log.error("wait() exception.", e);
		}
		
		Message message = queue.get(0);
		queue.remove(message);

		log.info(Thread.currentThread().getName() + "正在消费"
				+ message.getContent() + "。。。 ,当前个数: " + getCount());

		notifyAll();
	}

	/**
	 * @Title: getCount
	 * @Description: 获取队列中的当前个数
	 * @return [描述]
	 * @author 
	 */
	private int getCount() {

		synchronized (this) {
			return queue.size();
		}
	}
}

 

测试类 ：Test

  

/**
 * @ClassName: Test
 * @Description: 测试
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Test {

	/**@Title: main
	 * @Description: 测试
	 * @param args 
	 * @author 
	 */
	public static void main(String[] args) {

		MessageQueue queue = new MessageQueue();
		
		Producer wQ1 = new Producer(queue);
		Producer wQ2 = new Producer(queue);
	  
		Consumer rQ1 = new Consumer(queue);
		Consumer rQ2 = new Consumer(queue);
		Consumer rQ3 = new Consumer(queue);
	  
		Thread threadWQ1 = new Thread(wQ1, "thread-wQ1");
		Thread threadWQ2 = new Thread(wQ2, "thread-wQ2");

		Thread threadRQ1 = new Thread(rQ1, "thread-rQ1");
		Thread threadRQ2 = new Thread(rQ2, "thread-rQ2");
		Thread threadRQ3 = new Thread(rQ3, "thread-rQ3");
	  
		threadWQ1.start();
		threadWQ2.start();
	  
		threadRQ1.start();
		threadRQ2.start();
		threadRQ3.start();
	}

}