Java面试 每日一题：生产者消费者模型实现

生产者消费者问题是研究多线程程序时绕不开的经典问题之一。
问题描述：使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。

因为缓冲区属于临界资源，因此需要使用一个互斥量 mutex 来控制对缓冲区的互斥访问。

为了同步生产者和消费者的行为，需要记录缓冲区中物品的数量。数量可以使用信号量来进行统计，这里需要使用两个信号量：empty 记录空缓冲区的数量，full 记录满缓冲区的数量。其中，empty 信号量是在生产者进程中使用，当 empty 不为 0 时，生产者才可以放入物品；full 信号量是在消费者进程中使用，当 full 信号量不为 0 时，消费者才可以取走物品。

注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty = 0，此时生产者睡眠。消费者不能进入临界区，因为生产者对缓冲区加锁了，消费者就无法执行 up(empty) 操作，empty 永远都为 0，导致生产者永远等待下，不会释放锁，消费者因此也会永远等待下去。

使用Object的方法 wait() notify()/notifyAll()实现

获取锁和释放锁都是针对Object而言的，而和线程无关。试想如果和线程相关，那么一个线程就无法使用多个锁。

/*
 * 生产者消费者【传统版】
 * synchronized、wait、notify
 * 一个初始值0，两个线程交替操作五轮，一个加一，一个减一
 * 思想：
 * 1.线程操作资源类
 * 2.判断->干活->通知
 */
class Data{
	private int num = 0;
	public synchronized void increment(){
		//判断
		while(num!=0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//干活
		num++;
		System.out.println(Thread.currentThread().getName()+" invoked increment 操作,num="+num);
		//通知
		this.notifyAll();
	}
	public synchronized void decrement(){
		//判断
		while(num==0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//干活
		num--;
		System.out.println(Thread.currentThread().getName()+" invoked decrement 操作,num="+num);
		//通知
		this.notifyAll();
	}
}
 
public class ProductConsumer_1 {
	public static void main(String[] args) {
		Data data = new Data();
		new Thread(()->{
			for (int i = 1; i <= 5; i++) {
				data.increment();
			}
		},"线程1").start();
		new Thread(()->{
			for (int i = 1; i <= 5; i++) {
				data.decrement();
			}
		},"线程2").start();
	}
}

使用 wait() notify()/notifyAll()的缺点在于在生产者唤醒消费者或者消费者唤醒生产者时，由于生产者和消费者使用同一个锁，所以生产者也会将生产者唤醒，消费者也会将消费者唤醒。

举例：假设现在池子满了，然后有3个生产者被阻塞，现在一个消费者拿走一个item，调用notify，此时一个被阻塞的生产者被唤醒了。这个生产者向池子里放入一个产品，并执行notify意图唤醒被阻塞的消费者，此时这个notify有可能唤醒另外2个被阻塞的生产者中的一个。

Condition可以指定多个等待的条件，因此使用Condition可以解决这一问题。

使用ReentrantLock和Condition的await() signal()/signalAll()实现

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/*
 * 生产者消费者【传统版】
 * lock、await、signal
 * 一个初始值0，两个线程交替操作五轮，一个加一，一个减一
 * 思想：
 * 1.线程操作资源类
 * 2.判断->干活->通知
 */
class Data{
	private int num = 0;
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
 
	public void increment(){
		lock.lock();
		try {
			//判断
			while(num!=0) {
				try {
					condition1.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			//干活
			num++;
			System.out.println(Thread.currentThread().getName()+" invoked increment 操作,num="+num);
			//通知
			condition2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			
		}
		
	}
	public void decrement(){
		lock.lock();
		try {
			//判断
			while(num==0) {
				try {
					condition2.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			//干活
			num--;
			System.out.println(Thread.currentThread().getName()+" invoked decrement 操作,num="+num);
			//通知
			condition1.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			
		}
	}
}
 
public class ProductConsumer_1 {
	public static void main(String[] args) {
		Data data = new Data();
		new Thread(()->{
			for (int i = 1; i <= 5; i++) {
				data.increment();
			}
		},"线程1").start();
		new Thread(()->{
			for (int i = 1; i <= 5; i++) {
				data.decrement();
			}
		},"线程2").start();
	}
}