并发（17）：仿真（上）

àì夳堔傛蜴生んèń 2023-02-13 03:51 36阅读 0赞

并发最有趣也最令人兴奋的用法就是创建仿真。通过使用并发，仿真的每个构件都可以成为其自身的任务，这使得仿真更容易编程。许多视频游戏和电影的CGI动画都是仿真，前面所示的HorseRace.java和GreenhouseScheduler.java也可以被认为是仿真。

### 一、银行出纳员仿真 ###

这个经典的仿真可以表示任何属于下面这种类型的情况：对象随机地出现，并且要求由数量有限的服务器提供随机数量的服务时间。通过构建仿真可以确定理想的服务器数量。

在本例中，每个银行顾客要求一定数量的服务时间，这是出纳员必须花费在顾客身上，以服务顾客需求的时间单位的数量。服务时间的数量对每个顾客来说都是不同的，并且是随机确定的。另外，你不知道在每个时间间隔内有多少顾客会到达，因此这也是随机确定的：

package concurrency;
    
    import java.io.IOException;
    import java.util.LinkedList;
    import java.util.PriorityQueue;
    import java.util.Queue;
    import java.util.Random;
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 客户 只读对象不需要同步
     */
    class Customer {
    	private final int serviceTime;
    
    	public Customer(int tm) {
    		serviceTime = tm;
    	}
    
    	public int getServiceTime() {
    		return serviceTime;
    	}
    
    	public String toString() {
    		return "[" + serviceTime + "]";
    	}
    }
    
    /**
     * 客户顺序
     */
    class CustomerLine extends ArrayBlockingQueue<Customer> {
    
    	public CustomerLine(int maxLineSize) {
    		super(maxLineSize);
    	}
    
    	public String toString() {
    		if (this.size() == 0)
    			return "[Empty]";
    		StringBuilder result = new StringBuilder();
    		for (Customer customer : this) {
    			result.append(customer);
    		}
    		return result.toString();
    	}
    }
    
    /**
     * 客户生成
     */
    class CustomerGenerator implements Runnable {
    
    	private CustomerLine customers;
    	private static Random r = new Random();
    
    	public CustomerGenerator(CustomerLine cq) {
    		customers = cq;
    	}
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				TimeUnit.MILLISECONDS.sleep(r.nextInt(300));
    				customers.put(new Customer(r.nextInt(1000)));
    			}
    		} catch (InterruptedException e) {
    			System.out.println("CustomerGenerator interrupted");
    		}
    		System.out.println("CustomerGenerator 结束");
    	}
    }
    
    /**
     * 出纳员
     */
    class Teller implements Runnable, Comparable<Teller> {
    
    	private static int counter = 0;
    	private final int id = counter++;
    	// 客户在这个班次服务
    	private int customersServed = 0;
    	private CustomerLine customers;
    	private boolean servingCustomerLine = true;
    
    	public Teller(CustomerLine cq) {
    		customers = cq;
    	}
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				Customer customer = customers.take();
    				TimeUnit.MILLISECONDS.sleep(customer.getServiceTime());
    				synchronized (this) {
    					customersServed++;
    					while (!servingCustomerLine)
    						wait();
    				}
    			}
    		} catch (InterruptedException e) {
    			System.out.println(this + "interrupted");
    		}
    		System.out.println(this + "结束");
    	}
    
    	// 做其他的事情
    	public synchronized void doSomethingElse() {
    		customersServed = 0;
    		servingCustomerLine = true;
    	}
    
    	// 服务CustomerLine
    	public synchronized void serveCustomerLine() {
    		assert !servingCustomerLine : "already serving" + this;
    		servingCustomerLine = true;
    		notifyAll();
    	}
    
    	public String toString() {
    		return "Teller " + id + " ";
    	}
    
    	public String shortString() {
    		return "T" + id;
    	}
    
    	// 优先队列使用
    	@Override
    	public int compareTo(Teller o) {
    		return customersServed < o.customersServed ? -1 : (customersServed == o.customersServed ? 0 : 1);
    	}
    }
    
    /**
     * 出纳管理
     */
    class TellerManager implements Runnable {
    
    	private ExecutorService exec;
    	private CustomerLine customers;
    	private PriorityQueue<Teller> workingTellers = new PriorityQueue<Teller>();
    	private Queue<Teller> tellerDoingOtherThings = new LinkedList<Teller>();
    	private int adjustmentPeriod;
    	private static Random r = new Random();
    
    	public TellerManager(ExecutorService e, CustomerLine customers, int adjustmentPeriod) {
    		exec = e;
    		this.customers = customers;
    		this.adjustmentPeriod = adjustmentPeriod;
    		// 从单个出纳员开始
    		Teller teller = new Teller(customers);
    		exec.execute(teller);
    		workingTellers.add(teller);
    	}
    
    	public void adjustTellerNumber() {
    		// 这实际上是一个控制系统。通过调整数字，您可以揭示控制机制中的稳定性问题。如果队伍太长，添加另一个出纳员
    		if (customers.size() / workingTellers.size() > 2) {
    			// 如果出纳员休息或做其他工作，带一个回来
    			if (tellerDoingOtherThings.size() > 0) {
    				Teller teller = tellerDoingOtherThings.remove();
    				teller.serveCustomerLine();
    				workingTellers.offer(teller);
    				return;
    			}
    			// 否则创建(雇佣)一个新的出纳员
    			Teller teller = new Teller(customers);
    			exec.execute(teller);
    			workingTellers.add(teller);
    			return;
    		}
    		// 如果行足够短，删除一个出纳员
    		if (workingTellers.size() > 1 && customers.size() / workingTellers.size() < 2)
    			reassignOneTeller();
    		// 如果没有排队，我们只需要一个出纳员
    		if (customers.size() == 0)
    			while (workingTellers.size() > 1)
    				reassignOneTeller();
    	}
    
    	// 给出纳员一个不同的工作或休息
    	private void reassignOneTeller() {
    		Teller teller = workingTellers.poll();
    		teller.doSomethingElse();
    		tellerDoingOtherThings.offer(teller);
    	}
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				TimeUnit.MILLISECONDS.sleep(adjustmentPeriod);
    				adjustTellerNumber();
    				System.out.print(customers + " { ");
    				for (Teller teller : workingTellers) {
    					System.out.print(teller.shortString() + " ");
    				}
    				System.out.println("}");
    			}
    		} catch (InterruptedException e) {
    			System.out.println(this + "interrupted");
    		}
    		System.out.println(this + "结束");
    	}
    
    	public String toString() {
    		return "TellerManager ";
    	}
    }
    
    /**
     * 银行出纳员模拟
     */
    public class BankTellerSimulation {
    	static final int MAX_LINE_SIZE = 50;
    	static final int ADJUSTMENT_PERIOD = 1000;
    
    	public static void main(String[] args) throws NumberFormatException, InterruptedException, IOException {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		// 如果队伍太长，顾客就会离开
    		CustomerLine customers = new CustomerLine(MAX_LINE_SIZE);
    		exec.execute(new CustomerGenerator(customers));
    		// 经理将根据需要添加和删除出纳员
    		exec.execute(new TellerManager(exec, customers, ADJUSTMENT_PERIOD));
    		if (args.length > 0)
    			TimeUnit.SECONDS.sleep(new Integer(args[0]));
    		else {
    			System.out.println("Press 'Enter' to quit");
    			System.in.read();
    		}
    		exec.shutdownNow();
    	}
    }

Customer对象非常简单，只包含一个final int域。因为这些对象从来都不发生变化，因此它们是只读对象，并且不需要同步或使用volatile。在这之上，每个Teller任务在任何时刻都只从输入队列中移除一个Customer，并且在这个Customer上工作直至完成，因此Customer在任何时刻都只由一个任务访问。

CustomerLine表示顾客在等待被某个Teller服务时所排成的单一的行。这只是一个ArrayBlockingQueue，它具有一个toString()方法，可以按照我们希望的形式打印结果。

CustomerGenerator附着在CustomerLine上，按照随机的时间间隔向这个队列中添加Customer。

Teller从CustomerLine中取走Customer，在任何时刻他都只能处理一个顾客，并且跟踪在这个特定的班次中有他服务的Customer的数量。当没有足够多的顾客时，他会被告知去执行doSomethingElse()，而当出现了许多顾客的业务上，compareTo()方法将查看出纳员服务过的顾客数量，使得PriorityQueue可以自动地将工作量最小的出纳员推向前台。

TellerManager是各种活动的中心，它跟踪所有的出纳员以及等待服务的顾客。这个仿真中有一件有趣的事情，即它试图发现对于给定的顾客流，最优的出纳员数量是多少。你可以在adjustTellerNumber()中看到这一点， 这是一个控制系统，它能够以稳定的方式添加或移除出纳员。所有的控制系统都具有稳定性问题，如果它们对变化反映过快，那么它们就是不稳定的，而如果它们反映过慢，则系统会迁移到它的某种极端情况。

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