P737 仿真银行出纳员

public class Customer {
    private final int id  = count++;//加了ID
    private static int count = 0;//加了COUNT
    private final int serviceTime;
    public Customer(int tm){
        serviceTime = tm;
    }
    public int getServiceTime(){
        return serviceTime;
    }
    public String toString(){
        return "[customer" + id + "]";//加了CUSTOMER
    }
}

import java.util.concurrent.ArrayBlockingQueue;

public class CustomerLine extends ArrayBlockingQueue<Customer>{
    public  CustomerLine(int maxSize){
        super(maxSize);
    }
    public String toString(){
        if(this.size() == 0) return "[Empty]";
        StringBuilder result = new StringBuilder();
        for(Customer customer: this) result.append(customer);
        return result.toString();
    }
}

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class CustomerGenerator implements Runnable {
    private CustomerLine customers;
    private static Random rand = new Random(47);
    public CustomerGenerator(CustomerLine customers){
        this.customers = customers;
    }
    public void run(){
        try{
            while(!Thread.interrupted()){
                TimeUnit.MILLISECONDS.sleep(rand.nextInt(300));
                customers.put(new Customer(rand.nextInt(1000)));
            }
        }catch(InterruptedException e){
            System.out.println("CustomerGenerator interrupted");
        }
        System.out.println("CustomerGenerator terminating");
    }
}

import java.util.concurrent.TimeUnit;

public class Teller implements Runnable ,Comparable<Teller>{
    private static int count = 0;
    private final int id = count++;
    private boolean servingCustomerLine = true;
    private int customersServed = 0;
    private CustomerLine customers;

    public Teller(CustomerLine customers) {
        this.customers = customers;
    }

    public String toString() {
        return "Teller " + id + " ";
    }

    public String shortString() {
        return "T " + id;
    }

    public void run() {
        try {
            while (!Thread.interrupted()) {
                Customer customer = customers.take();
                System.out.println(this + " is serving " + customer);
                TimeUnit.MILLISECONDS.sleep(customer.getServiceTime());
                synchronized (this) {
                    customersServed++;
                    while (!servingCustomerLine) wait();
                }
            }
        } catch (InterruptedException e) {
            System.out.println(this + " is interrupted.");
        }
        System.out.println(this + " terminated");
    }

    public synchronized void doSomethingElse(){
        System.out.println(this + " is doing something else");
        servingCustomerLine = false;
        customersServed = 0;
    }

    public synchronized  void setCustomersServed(){
        assert !servingCustomerLine:"already serving: " + this;
        servingCustomerLine = true;
        notifyAll();
    }
    public synchronized int compareTo(Teller other){//排序方法
        return customersServed < other.customersServed ? -1 : (
                customersServed == other.customersServed ? 0 : 1
                );
    }
}

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

public class TellerManager implements Runnable {
    private ExecutorService exec;
    private CustomerLine customers;
    private PriorityQueue<Teller> workingTellers = new PriorityQueue<Teller>();
    private Queue<Teller> tellersDoingOtherThings = new LinkedList<Teller>();
    private int adjustmentPeriod;
    private static Random rand = new Random(47);

    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 (tellersDoingOtherThings.size() > 0) {
                Teller teller = tellersDoingOtherThings.remove();
                teller.setCustomersServed();
                workingTellers.offer(teller);
                return;
            }
            Teller teller = new Teller(customers);
            exec.execute(teller);
            workingTellers.offer(teller);
        } else if (workingTellers.size() > 1 && customers.size() / workingTellers.size() < 2) {
            reassignOneTeller();
        }
        if (customers.size() == 0) {
            while (workingTellers.size() > 1)
                reassignOneTeller();
        }
    }

    public void reassignOneTeller() {
        Teller teller = workingTellers.poll();
        teller.doSomethingElse();
        tellersDoingOtherThings.add(teller);
    }

    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 + "terminating");
    }

    public String toString() {
        return "TellerManager";
    }
}

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

public class BankerTellerSimulation {
    static final int MAX_LINE_SIZE = 50;
    static final int ADJUSTMENT_PERIOD = 1000;

    public static void main(String[] args) throws Exception {
        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();
    }
}