Java基于ReentrantLock类和Condition接口实现生产者消费者模型

测试用生产者模型：

package domain;

import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 生产者模型
 * 
 * @author WanAkiko
 * 
 */
public class Producer implements Runnable {

	private Queue<String> queue;
	private ReentrantLock lock;
	private Condition condition;
	private Integer count = 0;
	int i = 1;

	public Producer(Queue<String> queue, ReentrantLock lock,
			Condition condition, Integer count) {
		super();
		this.queue = queue;
		this.lock = lock;
		this.condition = condition;
		this.count = count;
	}

	@Override
	public void run() {
		while (true) {
			lock.lock();
			while (queue.size() >= count) {
				try {
					condition.await(); // 线程通信或中断之前保持等待状态
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			String msg = "生产序列-" + (i++);
			queue.add(msg);
			System.out.println("生产者线程：" + msg);
			condition.signal();
			lock.unlock();
		}
	}

}

测试用消费者模型：

package domain;

import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 消费者模型
 * 
 * @author WanAkiko
 * 
 */
public class Consumer implements Runnable {

	private Queue<String> queue; // 消费者队列
	@SuppressWarnings("unused")
	private Integer count; // 消费数量
	private ReentrantLock lock; // 唯一对象锁
	private Condition condition; // 监视器

	public Consumer(Queue<String> queue, Integer count, ReentrantLock lock,
			Condition condition) {
		super();
		this.queue = queue;
		this.count = count;
		this.lock = lock;
		this.condition = condition;
	}

	@Override
	public void run() {
		while (true) {
			lock.lock(); // 获取互斥锁
			while (queue.isEmpty()) {
				try {
					condition.await(); // 线程通信或中断之前保持等待状态
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			condition.signal();
			System.out.println("消费者线程：" + queue.remove());
			lock.unlock(); // 释放互斥锁
		}
	}
}

模型测试：

package client;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import domain.Consumer;
import domain.Producer;

public class PC02Test {

	public static void main(String[] args) {
		
		Queue<String> queue = new LinkedList<String>();
		ReentrantLock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		int count = 3;
		
		new Thread(new Producer(queue, lock, condition, count)).start();
		new Thread(new Consumer(queue, count, lock, condition)).start();
		
	}
	
}

运行示例：