java实例

最新推荐文章于 2024-05-28 12:49:26 发布

龙鱼入海

最新推荐文章于 2024-05-28 12:49:26 发布

阅读量494

点赞数

本文链接：https://blog.csdn.net/wygsqsj/article/details/50330227

版权

这一篇主要说一下两个程序示例，这两道题对于我们所学知识的综合利用有很大的帮助，对于很多知识点我们大多都是处于一知半解的状态，知道有这么回事，但是真正的开发利用中就是不知道如何下手，还有一些知识点是没有接触过，通过这两道题把所学的知识点串一下，更重要的是培养一种灵活运用所学知识的能力和学习的态度与方法。

一．交通灯管理系统

1.交通灯管理系统的要求

这个交通灯管理系统要求异步随机生成按照各个路线行驶的车辆。

例如：

由南向而来去往北向的车辆---- 直行车辆

由西向而来去往南向的车辆 ---- 右转车辆

由东向而来去往南向的车辆 ---- 左转车辆

。。。。。。

① 信号灯忽略黄灯，只考虑红灯和绿灯。

② 应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。

③ 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。

注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

④ 每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。

随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

2.系统分析

我们按照要求并联想现实生活中的实际路口来思考，凭借大多数人的大脑是无法在脑海中构建这个交通灯的全部情况，所以我们要通过画图来说明：

通过这张示意图我们可以看出来总共有12条路线，为了统一编程模型，可以假设每条路线都有一个红绿灯对其进行控制，右转弯的4条路线的控制灯可以假设称为常绿状态，另外，其他的8条线路是两两成对的（方向相反），可以归为4组，所以，程序只需考虑图中标注了数字号的4条路线的控制灯的切换顺序，这4条路线其所对应的相反方向的路线的控制灯跟随这4条路线切换，不必额外考虑。

也就是说第一条路线是由南向北行驶，我们用S2N表示，与他是一组的是N2S，因为他们虽然方向不同，但是可以被同状态的红绿灯控制，第二条线路是S2W，与他相对的是N2E，依次分析这个交通灯管理系统中总共有4条线路被红绿灯控制。

根据我们现实中的情况当①线路绿灯后，S2N和N2S方向上的车启动，当①红灯后，②线路绿灯，然后③线路，最后④线路，④线路红灯之后①线路接着绿灯。

3.面相对象的需求与分析

根据需求我们来分析一下本系统中需要用到哪些对象，红绿灯控制系统，首先要有车，然后车得用灯控制，车还得有行进的路线，汽车看到自己所在路线对应的灯绿了就能穿过路口吗？不是，还需要看其前面是否有车，看前面是否有车，就需要一个新的对象——路，路中存储着车辆的集合，显然路上就应该有增加车辆和减少车辆的方法了。再看题目，我们这里并不要体现车辆移动的过程，只是捕捉出车辆穿过路口的过程，也就是捕捉路上减少一辆车的过程，所以，这个车并不需要单独设计成为一个对象，用一个字符串表示就可以了。

每条路线上都会出现多辆车，路线上要随机增加新的车，在灯绿期间还要每秒减少一辆车。

（1）设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。

1>每条路线上随机增加新的车辆，增加到一个集合中保存。

2>每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。

3>每条路线每隔一秒都会检查控制本路线的灯是否为绿，一个灯由绿变红时，应该将下一个方向的灯变绿。

代码如下：

public class Road {
	//建立集合用来存储车（字符串）
	private List<String> vechicles = new ArrayList<String>();
	
	//每条路线都有着自己的名字，我们通过构造函数接收他的名字
	private String name =null;
	
	//在一个Road对象实例化的过程中开启一条线程来产生车辆
	public Road(String name){
		this.name = name;
		
		/*模拟车辆不断随机上路的过程
		 * 利用线程池来创建新的线程，在新的线程中添加车辆
		 * */		
		ExecutorService pool = Executors.newSingleThreadExecutor();
		pool.execute(new Runnable(){
			public void run(){
				//每条路上产生49辆车
				for(int i=1;i<50;i++){
					//随机暂停几秒后此道路添加车辆
					try {					
						Thread.sleep((new Random().nextInt(10) + 1) * 1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//内部类访问外部类的成员变量，可以加this，但因为局部变量名也为name，所以使用下面格式
					vechicles.add(Road.this.name + "_" + i);
				}				
			}			
		});
		
		/*每隔一秒检查对应的灯是否为绿，是则放行一辆车
		 * 利用调度池来构建一个定时器，每隔1秒来检测这条线对应的灯
		 * */		
		ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				//定时器要做的事情封装进Runnable当中
				new Runnable(){
					public void run(){
						//如果集合内有车，那么判断灯的状态
						if(vechicles.size()>0){
							boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
							if(lighted){
								//集合在删除元素时会把该元素返回来
								System.out.println(vechicles.remove(0) + "  号车通过路口!");
							}
						}
						
					}
				},
				1,//过多少时间量之后去做Runnable封装的事情
				1,//做完Runnable封装的事情之后再过多少时间量重新去做
				TimeUnit.SECONDS);//单位为秒
		
	}
}

（2）设计一个Lamp类来表示一个交通灯，每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。

1>总共有12条路线，所以，系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。

2>除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯,除去这两个变量之外，还要有一个变量记录自己的状态。

注意：无论在程序的什么地方去获得某个方向的灯时，每次获得的都是同一个实例对象，所以Lamp类改用枚举来做显然具有很大的方便性，永远都只有代表12个方向的灯的实例对象。

首先设计Lamp类来描述灯：

/*
 * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
 * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
 * 程序代码只需要控制每组灯中的一个灯即可：
 * s2n,n2s    
 * s2w,n2e
 * e2w,w2e
 * e2s,w2n
 * s2e,n2w
 * e2n,w2s
 * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，
 * 所以，可以假想它们总是绿灯。
 */

public enum Lamp {
	/*每个枚举元素各表示一个方向的控制灯，每一个枚举元素在初始化的时候要接收3个参数
	 * 1.相反方向的灯2.下一个要点亮的灯3.灯的状态*/	
	S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
	/*下面元素表示与上面的元素的相反方向的灯，它们的“相反方向灯”和“下一个灯”应忽略不计！*/
	N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
	/*由南向东和由西向北等右拐弯的灯不受红绿灯的控制，所以，可以假想它们总是绿灯*/
	S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
	
	//使用传递字符串的方式来获得灯的名字
	private Lamp(String opposite,String next,boolean lighted){
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}


	/*当前灯的状态*/	
	private boolean lighted;
	/*与当前灯同时为绿的对应方向*/	
	private String opposite;
	/*当前灯变红时下一个变绿的灯*/	
	private String next;
	//对外提供方法获取灯的状态
	public boolean isLighted(){
		return lighted;
	}
	
	/**
	 * 某个灯变绿时，它对应方向的灯也要变绿
	 */	
	public void light(){
		this.lighted = true;
		if(opposite != null){
			//valueOf方法可以通过字符串获取到其对应的对象
			Lamp.valueOf(opposite).light();
		}
		System.out.println(name() + " 灯变绿了，下面总共应该有6个方向能看到汽车穿过！");
		
	}
	
	/**
	 * 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿
	 * @return 下一个要变绿的灯
	 */	
	public Lamp blackOut(){
		//当前灯变红
		this.lighted = false;
		//对应的灯也变红
		if(opposite != null){
			Lamp.valueOf(opposite).blackOut();
		}		
		//下一个灯变绿
		Lamp nextLamp= null;
		if(next != null){
			nextLamp = Lamp.valueOf(next);
			System.out.println("绿灯从" + name() + "-------->切换为" + next);			
			nextLamp.light();
		}
		return nextLamp;
	}
}

设计一个LampController类，用来管理灯对象，它定时让当前的绿灯变红。

/*
 * 定义灯的控制器，在Lamp中只是定义了灯的属性和方法，而如何控制灯
 * 则由灯控制器来操作
 * */
public class LampController {
	//首先要定义成员变量表征当前的灯
	private Lamp currentLamp;
	
	//定义控制灯的方法
	public LampController(){
		//获取由南向北的灯
		currentLamp = Lamp.S2N;
		//S2N变绿，这样绿的是两个灯，北到南也绿了	
		currentLamp.light();
		
		/*每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿
		 * 使用定时器
		 * */		 
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				new Runnable(){
					public void run()
					{
						//把当前灯变黑，blackOut方法把下一个灯也变绿了
						currentLamp = currentLamp.blackOut();
					}
				},
				10,
				10, 
				TimeUnit.SECONDS);
		
	}
}

我们所有的对象都已经创建好了，现在我们创建主线程：

public class MainClass {

	public static void main(String[] args) {
		
		/*产生12个方向的路线，一个个new太麻烦交给for循环去做*/		
		String [] directions = new String[]{
				"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"		
		};
		for(int i=0;i<directions.length;i++){
			new Road(directions[i]);
		}
		
		/*产生整个交通灯系统*/		
		new LampController();
	}
}

运行主线程，就可以得到运行结果：

N2S 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

S2N 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

N2S_1 号车通过路口!

W2S_1 号车通过路口!

W2S_2 号车通过路口!

W2S_3 号车通过路口!

N2S_2 号车通过路口!

W2S_4 号车通过路口!

S2N_1 号车通过路口!

S2E_1 号车通过路口!

E2N_1 号车通过路口!

N2W_1 号车通过路口!

E2N_2 号车通过路口!

绿灯从S2N-------->切换为S2W

N2E 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

S2W 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

S2W_1 号车通过路口!

N2E_1 号车通过路口!

S2W_2 号车通过路口!

N2E_2 号车通过路口!

N2W_2 号车通过路口!

S2E_3 号车通过路口!

W2S_5 号车通过路口!

S2W_4 号车通过路口!

S2E_4 号车通过路口!

N2W_3 号车通过路口!

N2E_4 号车通过路口!

E2N_3 号车通过路口!

。。。。。。

由于是随机的，所以每次运行结果是不一致的，但是运行的状态就是这个样子。结果是我们一步一步做出来的，总结一下，这个红绿灯控制系统中我们使12条路线对应12个红绿灯，统一了系统模型，而每一个灯在系统中的对象都是唯一的，使用枚举，我们又通过分析发现只要控制4条路线就可以让这个交通灯系统运行，简化了代码的书写。通过这个示例我觉得我们在编程的时候首先要明确需求，通过需求来分析要使用哪些对象，然后去构建对象和使用对象。

二．银行业务调度系统

1.银行业务调度系统的要求

模拟实现银行业务调度系统逻辑，具体需求如下：

银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。

有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

异步随机生成各种类型的客户，生成各类型用户的概率比例为：

VIP客户：普通客户：快速客户 = 1 ：6 ：3。

客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值

各类型客户在其对应窗口按顺序依次办理业务。

当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。

2.面向对象的分析和设计

有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。

（1）首先，我们应该明确银行用来确定客户是通过一个取号机器来明确的，所以我们就想到需要有一个号码管理器对象，由于有三类客户，每类客户的号码编排都是完全独立的，所以，我想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

（2）各类型客户在其对应窗口按顺序依次办理业务，准确地说，应该是窗口依次叫号。各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

我们通过示意图来了解一下这个系统的构成：

我们来看一下代码的设计：定义号码管理器类：

/*
 * 定义号码管理器类，这个类中有产生新号码的方法和反馈给窗口号码的方法
 * 注意点：
 * 1. 由于产生的新号码并不是马上就被窗口获取到，所以每产生一个号码都需要存储
 * 起来等待窗口的调度，在此我们使用集合来存储产生的号码
 * 2.产生新号码和获取号码是不同的线程，多线程访问公有资源要加锁。
 * */
public class NumberManager {
	private int lastNumber = 0;
	private List queueNumbers = new ArrayList();
	
	//产生新的号码
	public synchronized Integer generateNewNumber(){
		queueNumbers.add(++lastNumber);
		return lastNumber;
	}
	//定义取得方法
	public synchronized Integer fetchNumber(){
		if(queueNumbers.size()>0){
			return (Integer)queueNumbers.remove(0);
		}else{
			return null;
		}
	}
}

然后设计取号器：

/*
 * 定义取号器类，这个类可以生成3个号码管理器对象
 * 由于取号器在银行系统中只有一个所以要设计成单例设计模式
 * */
public class NumberMachine {
	
	//私有本类构造函数，不能new对象
	private NumberMachine(){}
	//new一个本类对象以保证此类对象的唯一性
	private static NumberMachine instance = new NumberMachine();
	//对外提供方法将本类对象返回
	public static NumberMachine getInstance(){
		return instance;
	}
	
	
	//定义三个成员变量分别对应3个号码管理器对象
	private NumberManager commonManager = new NumberManager();//普通客户
	private NumberManager expressManager = new NumberManager();//快速客户
	private NumberManager vipManager = new NumberManager();//VIP客户
	public NumberManager getCommonManager() {
		return commonManager;
	}
	public NumberManager getExpressManager() {
		return expressManager;
	}
	public NumberManager getVipManager() {
		return vipManager;
	}
	
}

设计窗口：

public class ServiceWindow {
	
	
	private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");
	private CustomerType type = CustomerType.COMMON;
	private int number = 1;

	public CustomerType getType() {
		return type;
	}

	public void setType(CustomerType type) {
		this.type = type;
	}
	
	public void setNumber(int number){
		this.number = number;
	}
	
	//定义方法开启一条线程，这条线程执行取号的动作
	public void start(){
		Executors.newSingleThreadExecutor().execute(
				new Runnable(){
					public void run(){
						//下面这种写法的运行效率低，最好是把while放在case下面
						while(true){
							switch(type){
								case COMMON:
									commonService();
									break;
								case EXPRESS:
									expressService();
									break;
								case VIP:
									vipService();
									break;
							}
						}
					}
				}
		);
	}
	//为普通客户服务
	private void commonService(){
		String windowName = "第" + number + "号" + type + "窗口";		
		System.out.println(windowName + "开始获取普通任务!");
		//获取到普通客户所对应的号码管理器中的等待号
		Integer serviceNumber = NumberMachine.getInstance().getCommonManager().fetchNumber();		
		if(serviceNumber != null ){
			System.out.println(windowName + "开始为第" + serviceNumber + "号普通客户服务");	
			//在外部定义了常量类提供最大服务时间和最小时间
			int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
			//模拟客户的服务时间，利用Random随机生成最大值10秒和最小值1秒之间的任意秒
			int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;
	
			try {
				Thread.sleep(serviceTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			//当线程sleep之后醒来打印这个时间
			System.out.println(windowName + "完成为第" + serviceNumber + "号普通客户服务，总共耗时" + serviceTime/1000 + "秒");		
		}else{
			System.out.println(windowName + "没有取到普通任务，正在空闲一秒");		
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}				
		}
	}
	//为快速客户服务
	private void expressService(){
		//获取快速客户号码管理器反馈的号码
		Integer serviceNumber = NumberMachine.getInstance().getExpressManager().fetchNumber();
		String windowName = "第" + number + "号" + type + "窗口";	
		System.out.println(windowName + "开始获取快速任务!");		
		if(serviceNumber !=null){
			System.out.println(windowName + "开始为第" + serviceNumber + "号快速客户服务");
			//服务时间就是最小值1秒
			int serviceTime = Constants.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serviceTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}		
			System.out.println(windowName + "完成为第" + serviceNumber + "号快速客户服务，总共耗时" + serviceTime/1000 + "秒");		
		}else{
			//当没有获取到快速客户时切换为普通客户
			System.out.println(windowName + "没有取到快速任务！");				
			commonService();
		}
	}
	
	private void vipService(){
		//获取VIP客户的号码管理器反馈的号码
		Integer serviceNumber = NumberMachine.getInstance().getVipManager().fetchNumber();
		String windowName = "第" + number + "号" + type + "窗口";	
		System.out.println(windowName + "开始获取VIP任务!");			
		if(serviceNumber !=null){
			System.out.println(windowName + "开始为第" + serviceNumber + "号VIP客户服务");
			
			int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
			int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serviceTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}		
			System.out.println(windowName + "完成为第" + serviceNumber + "号VIP客户服务，总共耗时" + serviceTime/1000 + "秒");		
		}else{
			//当没有获取到VIP客户时切换为普通客户
			System.out.println(windowName + "没有取到VIP任务！");				
			commonService();
		}	
	}
}

在窗口的设计中我们使用到了一个枚举来获取三种类型的窗口：

public enum CustomerType {
	COMMON,EXPRESS,VIP;
	
	//根据定义的枚举对象名返回相应的中文表现形式
	public String toString(){
		String name = null;
		switch(this){
		case COMMON:
			name = "普通";
			break;
		case EXPRESS:
			name = "快速";
			break;
		case VIP:
			name = name();
			break;
		}
		return name;
	}
}

我们使用到了一些常量，我们把他单独封装成一个类：

/*
 * 定义常量类
 * */
public class Constants {
	public static int MAX_SERVICE_TIME = 10000; //每个客户服务最长时间10秒！
	public static int MIN_SERVICE_TIME = 1000; //每个客户服务最短时间1秒！	
}

最后设计主线程：

public class MainClass {
	
	private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");
	

	public static void main(String[] args) {
		//产生4个普通窗口
		for(int i=1;i<5;i++){
			ServiceWindow window =  new ServiceWindow();
			window.setNumber(i);
			window.start();
		}
	
		//产生1个快速窗口
		ServiceWindow expressWindow =  new ServiceWindow();
		expressWindow.setType(CustomerType.EXPRESS);
		expressWindow.start();
		
		//产生1个VIP窗口		
		ServiceWindow vipWindow =  new ServiceWindow();
		vipWindow.setType(CustomerType.VIP);
		vipWindow.start();		
		
		//普通客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						//产生新的普通客户
						Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();
						/**
						 * 采用logger方式，无法看到直观的运行效果，因为logger.log方法内部并不是直接把内容打印出出来，
						 * 而是交给内部的一个线程去处理，所以，打印出来的结果在时间顺序上看起来很混乱。
						 */
						//logger.info("第" + serviceNumber + "号普通客户正在等待服务！");
						System.out.println("第" + serviceNumber + "号普通客户正在等待服务！");						
					}
				},
				0,//马上就有客户产生
				Constants.COMMON_CUSTOMER_INTERVAL_TIME,
				TimeUnit.SECONDS);
		
		//快速客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();
						System.out.println("第" + serviceNumber + "号快速客户正在等待服务！");
					}
				},
				0,
				Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,
				TimeUnit.SECONDS);
		
		//VIP客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();
						System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");
					}
				},
				0,
				Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6, 
				TimeUnit.SECONDS);
	}

}

这MainClass类中使用到了一些常量，我们把他加到常量类Constants中：

public class Constants {
	public static int MAX_SERVICE_TIME = 10000; //每个客户服务最长时间10秒！
	public static int MIN_SERVICE_TIME = 1000; //每个客户服务最短时间1秒！
	
	/*每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
	 * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以，
	 * 1秒钟产生一个普通客户比较合理，通过让这个变量乘以不同值来控制3种客户间的比例关系*/	
	public static int COMMON_CUSTOMER_INTERVAL_TIME = 1; 	
}

这样我们的银行业务调度系统就设计完成了，我们运行一下可以看到，首先6的窗口都开始工作，准备获取其对应的任务，这个时候还没有客户被创建出来所以他们会等待一秒，在cpu不断的执行中各种类型的客户被创建出来了，就去对应的窗口执行，快速窗口和Vip窗口在没有对应的客户等待的情况下去为普通客户服务，这就是我们这个程序的运行结果。

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-------