并发（18）：仿真（中）

Bertha 。 2023-02-13 08:57 20阅读 0赞

### 二、饭店仿真 ###

这个仿真添加了更多的仿真组件，例如Order和Plate，从而充实了本章前面描述的Restaurant.java示例，并且它重用了枚举类型章节中的menu类。它还引入了java SE5的SynchronousQueue，这是一种没有内部容量的阻塞队列，因此每个put()都必须等待一个take()，反之亦然。这就像是你在把一个对象交给某人——没有任何桌子可以放置这个对象，因此只有在这个人伸出手，准备好接收这个对象时，你才能工作。在本例中，SynchronousQueue表示设置在用餐者前面的某个位置，以加强在任何时刻只能上一道菜这个概念。

本例中剩下的类和功能都遵循Restaurant.java的结构，或者是对实际的饭店操作的相当直接的映射：

package concurrency.restaurant2;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.SynchronousQueue;
    import java.util.concurrent.TimeUnit;
    
    import enumerated.menu.Course;
    import enumerated.menu.Food;
    
    /**
     * 这是给服务员的，服务员把它给厨师
     */
    class Order { // 数据传输对象
    	private static int counter = 0;
    	private final int id = counter++;
    	private final Customer customer;
    	private final WaitPerson waitPerson;
    	private final Food food;
    
    	public Order(Customer cust, WaitPerson wp, Food f) {
    		customer = cust;
    		waitPerson = wp;
    		food = f;
    	}
    
    	public Food item() {
    		return food;
    	}
    
    	public Customer getCustomer() {
    		return customer;
    	}
    
    	public WaitPerson getWaitPerson() {
    		return waitPerson;
    	}
    
    	public String toString() {
    		return "Order: " + id + " item: " + food + " for: " + customer + " served by: " + waitPerson;
    	}
    }
    
    /**
     * 这是厨师送来的
     */
    class Plate {
    	private final Order order;
    	private final Food food;
    
    	public Plate(Order ord, Food f) {
    		order = ord;
    		food = f;
    	}
    
    	public Order getOrder() {
    		return order;
    	}
    
    	public Food getFood() {
    		return food;
    	}
    
    	public String toString() {
    		return food.toString();
    	}
    }
    
    /**
     * 客户
     */
    class Customer implements Runnable {
    
    	private static int counter = 0;
    	private final int id = counter++;
    	private final WaitPerson waitPerson;
    	// 每次只能接受一道菜
    	private SynchronousQueue<Plate> placeSetting = new SynchronousQueue<>();
    
    	public Customer(WaitPerson w) {
    		waitPerson = w;
    	}
    
    	public void deliver(Plate p) throws InterruptedException {
    		// 只有当顾客还在吃上一道菜时才会阻塞
    		placeSetting.put(p);
    	}
    
    	@Override
    	public void run() {
    		for (Course course : Course.values()) {
    			Food food = course.randomSelection();
    			try {
    				waitPerson.placeOrder(this, food);
    				// 阻塞 直到上一道菜吃完
    				System.out.println(this + "eating " + placeSetting.take());
    			} catch (InterruptedException e) {
    				System.out.println(this + "waiting for " + course + " interrupted");
    				break;
    			}
    		}
    		System.out.println(this + "吃完饭,离开");
    	}
    
    	public String toString() {
    		return "Customer " + id + " ";
    	}
    }
    
    /**
     * 服务员
     */
    class WaitPerson implements Runnable {
    
    	private static int counter = 0;
    	private final int id = counter++;
    	private final Restaurant restaurant;
    	BlockingQueue<Plate> filledOrders = new LinkedBlockingQueue<>();
    
    	public WaitPerson(Restaurant rest) {
    		restaurant = rest;
    	}
    
    	public void placeOrder(Customer cust, Food food) {
    		try {
    			// 不应该阻塞，因为这是一个大小限制的LinkedBlockingQueue
    			restaurant.orders.put(new Order(cust, this, food));
    		} catch (InterruptedException e) {
    			System.out.println(this + " placeOrder interrupted");
    		}
    	}
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				// Blocks until a course is ready
    				Plate plate = filledOrders.take();
    				System.out.println(this + "收到了 " + plate + " 交付 " + plate.getOrder().getCustomer());
    				plate.getOrder().getCustomer().deliver(plate);
    			}
    		} catch (InterruptedException e) {
    			System.out.println(this + " interrupted");
    		}
    		System.out.println(this + " 下班");
    	}
    
    	public String toString() {
    		return "WaitPerson " + id + " ";
    	}
    }
    
    /**
     * 厨师
     */
    class Chef implements Runnable {
    	private static int counter = 0;
    	private final int id = counter++;
    	private final Restaurant restaurant;
    	private static Random r = new Random();
    
    	public Chef(Restaurant rest) {
    		restaurant = rest;
    	}
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				// 阻塞，直到出现一个订单
    				Order order = restaurant.orders.take();
    				Food requestedItem = order.item();
    				// 准备订单时间
    				TimeUnit.MILLISECONDS.sleep(r.nextInt(500));
    				Plate plate = new Plate(order, requestedItem);
    				order.getWaitPerson().filledOrders.put(plate);
    			}
    		} catch (InterruptedException e) {
    			System.out.println(this + " interrupted");
    		}
    		System.out.println(this + " 下班");
    	}
    
    	public String toString() {
    		return "Chef " + id + " ";
    	}
    }
    
    /**
     * 餐厅
     */
    class Restaurant implements Runnable {
    	private List<WaitPerson> waitPersons = new ArrayList<>();
    	private List<Chef> chefs = new ArrayList<>();
    	private ExecutorService exec;
    	private static Random r = new Random();
    	BlockingQueue<Order> orders = new LinkedBlockingQueue<>();
    
    	public Restaurant(ExecutorService e, int nWaitPersons, int nChefs) {
    		exec = e;
    		for (int i = 0; i < nWaitPersons; i++) {
    			WaitPerson waitPerson = new WaitPerson(this);
    			waitPersons.add(waitPerson);
    			exec.execute(waitPerson);
    		}
    		for (int i = 0; i < nChefs; i++) {
    			Chef chef = new Chef(this);
    			chefs.add(chef);
    			exec.execute(chef);
    		}
    	}
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				WaitPerson wp = waitPersons.get(r.nextInt(waitPersons.size()));
    				Customer c = new Customer(wp);
    				exec.execute(c);
    				TimeUnit.MILLISECONDS.sleep(100);
    			}
    		} catch (InterruptedException e) {
    			System.out.println("Restaurant interrupted");
    		}
    		System.out.println("Restaurant closing");
    	}
    }
    
    /**
     * 队列的餐厅
     */
    public class RestaurantWithQueues {
    	public static void main(String[] args) throws NumberFormatException, InterruptedException, IOException {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		Restaurant restaurant = new Restaurant(exec, 5, 2);
    		exec.execute(restaurant);
    		if (args.length > 0)
    			TimeUnit.SECONDS.sleep(new Integer(args[0]));
    		else {
    			System.out.println("Press 'Enter' to quit");
    			System.in.read();
    		}
    		exec.shutdownNow();
    	}
    }

关于这个示例，需要观察一项非常重要的事项，就是使用队列在任务间通信所带来的管理复杂度。这个单项技术通过反转控制极大的简化了并发编程的过程：任务没有直接地互相干涉，而是经由队列互相发送对象。接收任务将处理对象，将其当作一个消息来对待，而不是向它发送消息。如果只要可能就遵循这项技术，那么你构建出健壮的并发系统的可能性就会大大增加。

**如果本文对您有很大的帮助，还请点赞关注一下。**