Java线程学习笔记（九）生产者消费者问题

生产者消费者模式

最新推荐文章于 2024-12-07 20:05:31 发布

最新推荐文章于 2024-12-07 20:05:31 发布 · 126 阅读

文章标签：

#Java #多线程 #REST #thread #工作

Java 专栏收录该内容

34 篇文章

订阅专栏

通过多线程和BlockingQueue实现生产者消费者模式，模拟厨师生产产品和消费者消费的过程。

用多线程来模拟生产者消费者问题。用到BlockingQueue来实现更方便和安全。

模拟一个厨师生成产品，消费者消费，当产品数大于10的时候厨师休息，但产品数不够时厨师接着工作。

package com.woxiaoe.study.thread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 生产者 消费者 模拟
 * @author 小e
 *
 * 2010-4-29 下午09:32:43
 */

class Cook implements Runnable{
	private int productId;
	private BlockingQueue<Product> products;
	private boolean rest;
	public Cook(BlockingQueue<Product> products) {
		this.products = products;
	}
	public void product(){
		Product product = new Product(productId ++ );
		System.out.println("生产了" + product);
		products.add(product);
	}
	
	public boolean isRest() {
		return rest;
	}
	public void setRest(boolean rest){
		this.rest = rest;
	}
	@Override
	public void run() {
		try {
			while (!Thread.interrupted()) {
				synchronized (this) {
					while(products.size() >= 10){
						System.out.println("有剩余产品，厨师休息…………");
						rest = true;
						wait();
					}
				}
				product();// 50ms生产一个
				TimeUnit.MILLISECONDS.sleep(50);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("停止生产!");
		}
	}
}
class Product{
	private int productId;
	Product(int productId){
		this.productId = productId;
	}
	public int getProductId() {
		return productId;
	}
	
	@Override
	public String toString() {
		return "产品" + productId;
	}
}
class Customer implements Runnable{
	private BlockingQueue<Product> products;
	private String name;
	private Cook cook;
	public Customer(Cook cook,BlockingQueue<Product> products, String name) {
		this.cook = cook;
		this.products = products;
		this.name = name;
	}

	public void consume(){
		try {
			Product product = products.take();
			System.out.println(name + " 消费" + product);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
		}
	}

	@Override
	public void run() {
		try {
			while (!Thread.interrupted()) {
				consume();// 500消费一个
				synchronized (cook) {
					if(products.size() == 0 && cook.isRest()){
						cook.setRest(false);
						cook.notifyAll();
						System.out.println("库存不够，厨师开始工作……");
					}
				}
				TimeUnit.MILLISECONDS.sleep(500);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("用户:" + name + "停止消费!");
		}
		
	}
}
public class Restaurant {
	private Cook cook;
	
	public Restaurant(Cook cook) {
		this.cook = cook;
	}

	public static void main(String[] args) throws InterruptedException {
		
		System.out.println("饭馆开门");
		ExecutorService exec = Executors.newCachedThreadPool();
		BlockingQueue<Product> products = new LinkedBlockingQueue<Product>();
		Cook cook = new Cook(products);
		Restaurant restaurant = new Restaurant(cook);
		exec.execute(cook);
		for(int i = 0; i < 5; i++){
			exec.execute(new Customer(cook,products, "用户" +  i));
		}
		
		TimeUnit.SECONDS.sleep(2);//模拟五秒
		exec.shutdownNow();
		System.out.println("饭馆关门");
	}

}

Output：

饭馆开门

生产了产品0

用户0 消费产品0

生产了产品1

用户1 消费产品1

生产了产品2

用户2 消费产品2

生产了产品3

用户4 消费产品3

生产了产品4

用户3 消费产品4