大致百度了下发现其实实现方式还挺多的。
1. synchronized + Object对象的wait()和notifyAll()
我的项目包结构如下：
生产者接口Producer.java
public interface Producer {
void produce() throws InterruptedException;
}
消费者接口Consumer.java
public interface Consumer {
void consume() throws InterruptedException;
}
为什么抛出异常呢，因为在使用Object对象的wait方法阻塞让出资源的时候，该方法会抛出这个异常。
AbstractProducer.java，在这个类中通过构造参数传入每次操作休眠时间sleepTime，然后在run方法中进行死循环的生产方法produce调用：
public abstract class AbstractProducer implements Producer, Runnable{
private int sleepTime = -1;
public AbstractProducer(){
this(50); // 默认休眠时间
}
public AbstractProducer(int sleepTime){
this.sleepTime = sleepTime;
}
@Override
public void run() {
while(true){
try {
produce();
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
类似的处理AbstractConsumer.java，在该类中死循环调用消费方法：
public abstract class AbstractConsumer implements Consumer, Runnable{
private int sleepTime = -1;
public AbstractConsumer(){
this(50); // 默认休眠时间
}
public AbstractConsumer(int sleepTime){
this.sleepTime = sleepTime;
}
@Override
public void run() {
while(true){
try {
consume();
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
然后在Model.java类中指定仓库最大容量MAX_CAPACITY，为了记录生产编号，我使用了volatile int number来保证多线程下的可见性。使用LinkedList链表来模拟一个仓库，接着实现对应的生产者和消费者。
public class Model {
private static final int MAX_CAPACITY = 5; // 仓库容量
private static volatile int number = 0; // 生产编号
// 任务
static class Task{
public int number;
public Task(int number){
this.number = number;
}
}
// 仓库
static LinkedList<Task> queue = new LinkedList<>();
// 消费者
static class RealConsumer extends AbstractConsumer{
public RealConsumer(int sleepTime) {
super(sleepTime);
}
@Override
public void consume() throws InterruptedException {
synchronized (queue){
String name = Thread.currentThread().getName();
//多线程判断中使用 while 不要使用 if 否则会出现虚假唤醒问题
while(queue.size() == 0){
System.out.println("【消费者 "+ name + "】：仓库没有货物了，暂时不能执行消费任务！");
queue.wait(); // 让出资源
}
Task task = queue.pop();// 消费一个资源
System.out.println("【消费者 "+ name + "】：消费了资源"+task.number+"，当前仓库容量为："+queue.size());
queue.notifyAll(); // 唤醒在此对象监视器上等待的所有线程。
}
}
}
// 生产者
static class RealProcuder extends AbstractProducer{
public RealProcuder(int sleepTime) {
super(sleepTime);
}
@Override
public void produce() throws InterruptedException {
synchronized (queue){
String name = Thread.currentThread().getName();
while(queue.size() == MAX_CAPACITY){
System.out.println("【生产者 "+ name +"】：仓库满了，暂时不能进行生产操作！");
queue.wait();
}
queue.push(new Task(number));
System.out.println("【生产者 " + name +"】：生产了一个编号为"+number+"的产品，当前仓库容量为："+queue.size());
number++;
queue.notifyAll(); // 唤醒在此对象监视器上等待的所有线程。
}
}
}
}
需要注意的是在判断是否还有资源的时候，即wait()之前使用的是while而不是if，主要是为了防止虚假唤醒。在JDK文档中有说明：
最后我们写一个4个消费者，8个生产者的测试案例：
public class Test {
public static void main(String[] args) {
for (int i = 0; i < 4; i++) {
Model.RealConsumer realConsumer = new Model.RealConsumer(500);
new Thread(realConsumer, ""+i).start();
}
for (int i = 0; i < 8; i++) {
Model.RealProcuder realProcuder = new Model.RealProcuder(500);
new Thread(realProcuder, ""+i).start();
}
}
}
结果：
2. Lock + Condition的await()和signal()
我们知道Lock和synchronized都是可重入锁，锁的可重入性标明了锁是针对线程分配方式而不是针对方法。例如调用Synchronized方法A中可以调用Synchronized方法B，而不需要重新申请锁。
主要有以下区别：
synchronized是Java的关键字，在Jvm层面上；Lock是一个接口。Synchronized在线程发生异常时会自动释放锁，因此不会发生异常死锁。线程执行发生异常，Jvm会让线程释放锁。Lock异常时不会自动释放锁，所以需要在finally中实现释放锁。Lock是可以中断锁，锁的状态可以判断；Synchronized是非中断锁，锁的状态无法判断，必须等待线程执行完成释放锁。Synchronized为非公平锁；Lock默认为非公平锁，可以指定为公平锁。- 在资源竞争不是很激烈的情况下，
Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍。 - 使用
synchronized来进行线程间调度的时候，使用Object对象本身的wait、notify、notifyAll调度机制；Lock则可以使用Condition的await、signal进行线程之间的调度。 synchronized底层依赖指令码方式来控制锁，Lock依赖CAS乐观锁。
只需要简单替换下锁和唤醒的部分：
public class Model {
private static final int MAX_CAPACITY = 5; // 仓库容量
private static volatile int number = 0; // 生产编号
private static Lock lock = new ReentrantLock();
private static Condition consumerCondition = lock.newCondition();
private static Condition producerCondition = lock.newCondition();
// 任务
private static class Task{
public int number;
public Task(int number){
this.number = number;
}
}
// 仓库
private static LinkedList<Task> queue = new LinkedList<>();
// 消费者
static class RealConsumer extends AbstractConsumer{
public RealConsumer(int sleepTime) {
super(sleepTime);
}
@Override
public void consume() throws InterruptedException {
lock.lock();
try{
String name = Thread.currentThread().getName();
while(queue.size() == 0){
System.out.println("【消费者 "+ name + "】：仓库没有货物了，暂时不能执行消费任务！");
consumerCondition.await();
}
Task task = queue.pop();
System.out.println("【消费者 "+ name + "】：消费了资源"+task.number+"，当前仓库容量为："+queue.size());
consumerCondition.signal();
}finally {
lock.unlock();
}
}
}
// 生产者
static class RealProcuder extends AbstractProducer{
public RealProcuder(int sleepTime) {
super(sleepTime);
}
@Override
public void produce() throws InterruptedException {
lock.lock();
try{
String name = Thread.currentThread().getName();
while(queue.size() == MAX_CAPACITY){
System.out.println("【生产者 "+ name +"】：仓库满了，暂时不能进行生产操作！");
consumerCondition.await();
}
queue.push(new Task(number));
System.out.println("【生产者 " + name +"】：生产了一个编号为"+number+"的产品，当前仓库容量为："+queue.size());
number++;
consumerCondition.signal();
}finally {
lock.unlock();
}
}
}
}
注意lock的unlock()方法在try-finally中以保证锁的释放。结果同样截取部分：
3. BlockingQueue实现
生产put，在队列在大于容量的时候，就会阻塞当前线程。
消费take，队列中没有消息时，会阻塞，直到有消息消费。
其内部也是使用ReentrantLock来实现的。比如put和take方法：
// ArrayBlockingQueue.java
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e); // 该方法会调用signal()方法
} finally {
lock.unlock();
}
}
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue(); // 该方法会调用signal()方法
} finally {
lock.unlock();
}
}
9212
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
