生产者消费者_线程并发协作(生产者/消费者模式)

多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。

Ø 什么是生产者?

生产者指的是负责生产数据的模块(这里模块可能是：方法、对象、线程、进程)。

Ø 什么是消费者?

消费者指的是负责处理数据的模块(这里模块可能是：方法、对象、线程、进程)。

Ø 什么是缓冲区?

消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

1、缓冲区是实现并发的核心，缓冲区的设置有3个好处：

Ø 实现线程的并发协作

有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况;同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。

Ø 解耦了生产者和消费者

生产者不需要和消费者直接打交道。

Ø 解决忙闲不均，提高效率

生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费;消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据 。

2、生产者与消费者模式

商品类（面包）：

public class Goods {
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Goods(int id, String name) {
		this.id = id;
		this.name = name;
	}
	public Goods() {}
}

生产者线程类：

public class Producer implements Runnable{
	private Basket basket;
	public Producer(Basket basket) {
		this.basket = basket;
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Goods good = new Goods(i+1, "面包");
			System.out.println(Thread.currentThread().getName() 
                       + "生产了" + good.getId() + "号" + good.getName());
			basket.push(good);
		}
	}	
}

消费者线程类：

public class Customer implements Runnable{
	private Basket basket;
	public Customer(Basket basket) {
		this.basket = basket;
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Goods good = basket.pop();
			System.out.println(Thread.currentThread().getName() 
                       + "吃了" + good.getId() + "号" + good.getName());
		}
	}
}

缓冲区（篮子）：

public class Basket {
	Goods[] goods = new Goods[5];
	int index;//记录篮子中面包的个数
	
	public synchronized void push(Goods good) {
		//条件成立说明篮子放满了
		if(index == goods.length) {
			try {
				//wait()后，线程会将持有的锁释放，进入阻塞状态
				//这样其他需要锁的线程就可以获得锁
				this.wait();
				//这里的含义就是执行此方法的线程暂停，进入阻塞状态
				//等消费者消费了产品后再生产
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		goods[index] = good;
		index++;
		//唤醒在当前对象等待池中等待的第一个线程
		//notifyAll()唤醒所有在当前对象等待池中等待的所有线程
		this.notify();
		//如果不唤醒，以后这两个线程都会进入等待线程，没有人唤醒
	}
	public synchronized Goods pop() {
		//如果篮子空了就暂停消费线程，等生产线程生产出产品再消费
		if(index == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		index--;
		this.notify();
		return goods[index];
	}
}

测试类：

public class Test {
	public static void main(String[] args) {
		//定义缓冲区对象（同一个篮子）
		Basket basket = new Basket();
		Producer producer = new Producer(basket);
		Customer customer = new Customer(basket);
		Thread proThread = new Thread(producer, "面包师");
		Thread cusThread = new Thread(customer, "吃货");
		proThread.start();
		cusThread.start();
	}
}

运行结果：

3、线程并发协作总结：

线程并发协作(也叫线程通信)，通常用于生产者/消费者模式，情景如下：

1. 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

2. 对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。

3. 对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。

4. 在生产者消费者问题中，仅有synchronized是不够的。

· synchronized可阻止并发更新同一个共享资源，实现了同步;

· synchronized不能用来实现不同线程之间的消息传递(通信)。

5. 那线程是通过哪些方法来进行消息传递(通信)的呢?见如下总结：

6. 以上方法均是java.lang.Object类的方法;都只能在同步方法或者同步代码块中使用，否则会抛出异常。

老鸟建议

在实际开发中，尤其是“架构设计”中，会大量使用这个模式。 对于初学者了解即可，如果晋升到中高级开发人员，这就是必须掌握的内容。

尚学堂百战程序员

百战程序员_IT6000集_影响6000万学习IT的中国人【官网】