银行柜台业务调度系统

package com.tianRanDai.interview.bankOperation;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class Test {
	public static void main(String[] args) {
		//普通客户队列集合
	    BlockingQueue<Customer> ordinaryCustomers  = new ArrayBlockingQueue<Customer>(100,false);
		//快速客户队列集合
		BlockingQueue<Customer> quickCustomers = new ArrayBlockingQueue<Customer>(20,false) ;
		//VIP客户队列集合
	    BlockingQueue<Customer> VIPCustomers =new ArrayBlockingQueue<Customer>(20,false);
		//初始化银行服务台
		BankReception bankReception = new BankReception(8,2,2);
		CustomerScheduer customerScheduer = CustomerScheduer.newInstance(ordinaryCustomers,quickCustomers,VIPCustomers);
		customerScheduer.init();
		BankReceptionController.newInstance(bankReception, customerScheduer).init();
		
	}
}

package com.tianRanDai.interview.bankOperation;

/**
 * 客户等级
 * @author hadoop
 *
 */
public enum CustomerLevel {
	Ordinary,Quick,VIP;
}

package com.tianRanDai.interview.bankOperation;

/**
 * 客户
 * @author hadoop
 *
 */
public class Customer {
	private int  num ;
	private CustomerLevel level;
	public Customer(){};
	public Customer(int num, CustomerLevel level){
		this.num = num;
		this.level = level;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public CustomerLevel getLevel() {
		return level;
	}
	public void setLevel(CustomerLevel level) {
		this.level = level;
	}
	
	
}

package com.tianRanDai.interview.bankOperation;

import java.util.Random;
import java.util.concurrent.BlockingQueue;

/**
 * 用于产生客户
 * @author hadoop
 *
 */
public class GenCustormer {
	/**
	 * 
	 * @param customers
	 * @param level
	 * @param times
	 */
	public static synchronized void genCustormer(BlockingQueue<Customer> customers, CustomerLevel level, int times) {
		
		try {
			Thread.sleep((new Random().nextInt(times)+1)*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		if(customers.isEmpty()){
			Customer customer  = new Customer(1,level);
			try {
				//将一名客户加入对应等级的客户队列
				customers.put(customer);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("第"+customer.getNum()+"位"+level.name()+"客户正在等待！");
		}else{
			Customer customer = new Customer(customers.size(),level);
			try {
				//将一名客户加入对应等级的客户队列
				customers.put(customer);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("第"+(customer.getNum()+1)+"位"+level.name()+"客户正在等待！");
		}
		
	}

}

package com.tianRanDai.interview.bankOperation;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 客户调度器，用于产生客户并给个客户分组
 */
public class CustomerScheduer {
	
	//普通客户队列集合
	private  BlockingQueue<Customer> ordinaryCustomers ;
	//快速客户队列集合
	private  BlockingQueue<Customer> quickCustomers ;
	//VIP客户队列集合
	private  BlockingQueue<Customer> VIPCustomers ;
	
	
	private static CustomerScheduer instance;
	private CustomerScheduer(){};
	private CustomerScheduer(BlockingQueue<Customer> ordinaryCustomers,BlockingQueue<Customer> quickCustomers ,BlockingQueue<Customer> VIPCustomers){
		this.ordinaryCustomers = ordinaryCustomers;
		this.quickCustomers = quickCustomers;
		this.VIPCustomers = VIPCustomers;
	};
	/**
	 * 单例出客户调度器
	 * @param ordinaryCustomers
	 * @param quickCustomers
	 * @param VIPCustomers
	 * @return
	 */
	public static CustomerScheduer newInstance(
			BlockingQueue<Customer> ordinaryCustomers,BlockingQueue<Customer> quickCustomers ,BlockingQueue<Customer> VIPCustomers){
		if(instance!=null){
			return instance;
		}
		return new CustomerScheduer(ordinaryCustomers,quickCustomers,VIPCustomers);
	}
	
	/**
	 * 启动4个线程来产生客户，并对客户分组
	 */
	public void init(){
		int doorsNum = 4;
		ExecutorService genCustomerPool =  Executors.newFixedThreadPool(doorsNum);
		for(int i = 0 ;i<doorsNum;i++){
			genCustomerPool.execute(new Runnable(){
				@Override
				public void run() {
					for(int i=0;i<1000;i++){
						GenCustormer.genCustormer(ordinaryCustomers, CustomerLevel.Ordinary,1);//要求1～2秒
						GenCustormer.genCustormer(quickCustomers, CustomerLevel.Quick,7);//要求1～8秒
						GenCustormer.genCustormer(VIPCustomers, CustomerLevel.VIP,7);//要求1~8秒
					}
				}
				
			});
		}
	}
	
	public BlockingQueue<Customer> getOrdinaryCustomers() {
		return ordinaryCustomers;
	}
	public void setOrdinaryCustomers(BlockingQueue<Customer> ordinaryCustomers) {
		this.ordinaryCustomers = ordinaryCustomers;
	}
	public BlockingQueue<Customer> getQuickCustomers() {
		return quickCustomers;
	}
	public void setQuickCustomers(BlockingQueue<Customer> quickCustomers) {
		this.quickCustomers = quickCustomers;
	}
	public BlockingQueue<Customer> getVIPCustomers() {
		return VIPCustomers;
	}
	public void setVIPCustomers(BlockingQueue<Customer> customers) {
		VIPCustomers = customers;
	}

	
}

package com.tianRanDai.interview.bankOperation;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 银行业务控制器
 * @author hadoop
 *
 */
public class BankReceptionController {
	Semaphore semaphore = new Semaphore(6);
	//银行服务台
	private BankReception bankReception;
	//客户调度器
	private CustomerScheduer customerScheduer;
	
	private BankReceptionController(){};
	private static BankReceptionController instance;
	
	//下面属性均为附加属性
	
	//普通窗口的个数
	private int ordinaryWindowsNum ;
	//快速窗口的个数
	private int quickWindowsNum ;
	//VIP窗口的个数
	private int VIPWindowsNum ;
	
	
	//单例出银行业务调度器
	public static BankReceptionController newInstance(BankReception bankReception, CustomerScheduer customerScheduer){
		if(instance!=null){
			return instance;
		}
		return new BankReceptionController(bankReception,customerScheduer);	
		
	}
	private  BankReceptionController(BankReception bankReception ,CustomerScheduer customerScheduer){
		this.bankReception = bankReception;
		this.customerScheduer = customerScheduer;
		//下面属性均为附加属性初始化
		this.ordinaryWindowsNum = bankReception.getOrdinaryWindowsNum();
		this.quickWindowsNum = bankReception.getQuickWindowsNum();
		this.VIPWindowsNum = bankReception.getVIPWindowsNum();
	}
	
	/**
	 * 银行开始服务
	 */
	public void init(){
		//普通服务窗口线程池
		ExecutorService odinaryWindows =  Executors.newFixedThreadPool(bankReception.getOrdinaryWindowsNum());
		//快速服务窗口线程池
		ExecutorService quickWindows =  Executors.newFixedThreadPool(bankReception.getQuickWindowsNum());
		//VIP服务窗口线程池
		ExecutorService VIPWindows =  Executors.newFixedThreadPool(bankReception.getVIPWindowsNum());
		//启动多个普通窗口服务线程，并对普通客户服务
		for(int i=1;i<=ordinaryWindowsNum;i++){
			
			final int seq = i;
			odinaryWindows.execute(new Runnable(){
				//处理普通业务
				@Override
				public void run() {
					while(true){
						int time1 = (new Random().nextInt(25)+20)*1000;
						int time2 = 0;
						int time3 =  20;
						//产生服务结果
						Customer record = 
							BankReceptionController.this.ordinaryService(time1,time2,time3);
						if(record!=null){
							System.out.println("第"+seq+"号普通窗口服务了："+"第"+record.getNum()+"号"+record.getLevel()+"客户");
						}
					}
					
					
				}

				
				
			});
		}
		//启动多个快速窗口服务线程，并对快速客户和普通客户服务
		for(int i=1;i<=quickWindowsNum;i++){
			
			final int seq = i;
			quickWindows.execute(new Runnable(){

				@Override
				public void run() {
					while(true){
						int time1 = (new Random().nextInt(2)+4)*1000;
						int time2 = (new Random().nextInt(20)+20)*1000;
						int time3 =  0;
						//产生服务结果
						Customer record = 
							BankReceptionController.this.quickService(time1,time2,time3);
						if(record!=null){
							System.out.println("第"+seq+"号快速窗口服务了："+"第"+record.getNum()+"号"+record.getLevel()+"客户");
						}
						
					
					}
				}
				
			});
		}
		//启动多个VIP窗口服务线程，并对VIP客户和普通客户服务
		for(int i=1;i<=VIPWindowsNum;i++){
			final int seq = i;
			VIPWindows.execute(new Runnable(){
					@Override
					public void run() {
						while(true){
							int time1 = (new Random().nextInt(5)+10)*1000;//执行普通业务耗时 5~10 秒 
							int time2 = (new Random().nextInt(20)+20)*1000;//执行最高级任务耗时 5~10 秒 
							int time3 =  0;
							//产生服务结果
							Customer record = 
								BankReceptionController.this.VIPService(time1,time2,time3);
							if(record!=null){
								System.out.println("第"+seq+"号VIP窗口服务了："+"第"+record.getNum()+"号"+record.getLevel()+"客户");
							}
						}
						
					}
				
			});
		}
	}
	/**
	 * 电费水费窗口
	 * @param time1
	 * @param time2
	 * @param time3
	 * @param time4
	 * @return
	 */
	protected Customer quickService(int time1, int time2, int time3) {
		while(customerScheduer.getQuickCustomers().isEmpty()){
			if(!customerScheduer.getOrdinaryCustomers().isEmpty()&&customerScheduer.getOrdinaryCustomers().size()>ordinaryWindowsNum){
				
				return getRecord(customerScheduer.getOrdinaryCustomers(), time2);
			}
		}
		return getRecord(customerScheduer.getQuickCustomers(),time1);
	}
	
	/**
	 * VIP窗口
	 * @param time1
	 * @param time2
	 * @param time3
	 * @param time4
	 * @return
	 */
	protected   Customer VIPService(int time1, int time2, int time3) {
		while(customerScheduer.getVIPCustomers().isEmpty()){
			if(!customerScheduer.getOrdinaryCustomers().isEmpty()&&customerScheduer.getOrdinaryCustomers().size()>ordinaryWindowsNum){
				return getRecord(customerScheduer.getOrdinaryCustomers(), time2);
			}
		}
		return getRecord(customerScheduer.getVIPCustomers(),time1);
	}
	/**
	 * 普通窗口
	 * @param time1
	 * @param time2
	 * @param time3
	 * @param time4
	 * @return
	 */
	protected   Customer ordinaryService(
			int time1, int time2, int time3) {
		
		while(customerScheduer.getOrdinaryCustomers().isEmpty()){
			try {
				//短等
				Thread.sleep(time3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		
		return getRecord(customerScheduer.getOrdinaryCustomers(),time1);
	}
	
	
//	protected  Customer service(BlockingQueue<Customer> firstQueue,BlockingQueue<Customer> secondQueue,int time1,int time2,int time3,int time4) {
//		
//			try {
//				semaphore.acquire();
//			} catch (InterruptedException e1) {
//				// TODO Auto-generated catch block
//				e1.printStackTrace();
//			}
//			while(firstQueue.isEmpty()){
//				//优先级最高的队列为空时
//				if(secondQueue!=null){
//					
//					if(secondQueue.isEmpty()){
//						try {
//							//长等
//							Thread.sleep(time4);
//						} catch (InterruptedException e) {
//							e.printStackTrace();
//						}
//					}else{
//						System.out.println(Thread.currentThread().getName()+"开始处理服务2");
//						return getRecord(secondQueue,time2);
//					}
//				}else{
//					try {
//						//短等
//						Thread.sleep(time3);
//					} catch (InterruptedException e) {
//						e.printStackTrace();
//					}
//				}
//			}
//			System.out.println(Thread.currentThread().getName()+"开始处理服务1");
//			return getRecord(firstQueue,time1);
//			
//			//优先级最高的队列不为空时
//	}
		
	/**
	 * 产生服务结果
	 */
	private  Customer getRecord(BlockingQueue<Customer> Queue,int time) {
		Customer record = null;
		try {
			long startTime = System.currentTimeMillis();
				
				Thread.sleep(time);
			
			long endTime = System.currentTimeMillis();
			System.out.println("处理本次业务耗时："+(endTime-startTime)/1000+"秒");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		try {
			record = Queue.take();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		semaphore.release();
		return record;
	}
	
	public BankReception getBankReception() {
		return bankReception;
	}
	public void setBankReception(BankReception bankReception) {
		this.bankReception = bankReception;
	}
	
	
	public CustomerScheduer getCustomerScheduer() {
		return customerScheduer;
	}
	public void setCustomerScheduer(CustomerScheduer customerScheduer) {
		this.customerScheduer = customerScheduer;
	}
	
	
}

package com.tianRanDai.interview.bankOperation;

/**
 * 银行
 * @author hadoop
 *
 */
public class BankReception {
	//普通窗口的个数
	private int ordinaryWindowsNum ;
	//快速窗口的个数
	private int quickWindowsNum ;
	//VIP窗口的个数
	private int VIPWindowsNum ;
	public  BankReception(){
		
	}
	public  BankReception(int ordinaryWindowsNum,int quickWindowsNum,int VIPWindowsNum){
		this.ordinaryWindowsNum = ordinaryWindowsNum;
		this.quickWindowsNum = quickWindowsNum;
		this.VIPWindowsNum = VIPWindowsNum;
		
	}
	

	public int getOrdinaryWindowsNum() {
		return ordinaryWindowsNum;
	}

	public void setOrdinaryWindowsNum(int ordinaryWindowsNum) {
		this.ordinaryWindowsNum = ordinaryWindowsNum;
	}

	public int getQuickWindowsNum() {
		return quickWindowsNum;
	}

	public void setQuickWindowsNum(int quickWindowsNum) {
		this.quickWindowsNum = quickWindowsNum;
	}

	public int getVIPWindowsNum() {
		return VIPWindowsNum;
	}

	public void setVIPWindowsNum(int windowsNum) {
		VIPWindowsNum = windowsNum;
	}
	
	
}