黑马程序员——java基础学习（银行业务调度系统）

----------------------
ASP.Net+Android+IOS开发</a>、.Net培训、期待与您交流！ ----------------------

需求：

     银行内有6个业务窗口，1- 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
     有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

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

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

     客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。

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

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

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

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

分析：

     客户类型(ServerNumberQueue)将客户类型看成是要服务的号。固定为三种类型（VIP客户 、普通客户、快速客户），可通过枚举实现。里面用List存储当前等待服务的对象。

          因为因为三个窗口可能会同时操作普通客户，所以要注意数据的正确性。用同步代码块来保证。

     客户类型机器(ServerNumberMachine)用于自动三种类型的客户服务号。

     服务窗口(ServiceWindow)服务客户。有三种类型窗口。

各个类的实现：

     客户类型(ServerNumberQueue)

public enum ServerNumberQueue {
VIP, COMMON, FAST;
private List<String> numberQueue;//存储当前等待服务的客户号码队列
private int currentNumber;		//记录当前客户号

private ServerNumberQueue() {
this.numberQueue = new LinkedList<String>();
//建立客户对象时，让客户号从一个4000－4999的随机数开始
this.currentNumber = new Random().nextInt(1000) + 4000;
}

public synchronized void setCurrentNumber(int num) {
if (this.numberQueue.size() == 0) {
this.currentNumber = num;
}
}
/*
* 当服务窗口为一个对象服务完毕，调用该方法将服务号从队列中移除
*   可能多个服务窗口会同时服务，要加同步代码块
*/
public synchronized String fetchNumber() {
if (this.numberQueue.size() > 0) {
return this.numberQueue.remove(0);
}
return null;
}
/*
* 当客户管理器产生了一个客户时，将其添加到队列中
*/
public synchronized String generateNumber() {
this.numberQueue.add(this.name() + " customer " + currentNumber++);
//System.err.println(this.numberQueue);
return this.numberQueue.get((this.numberQueue.size() - 1));
}

public synchronized int getQueueCount() {
return this.numberQueue.size();
}
}

     客户类型机器(ServerNumberMachine)

public class ServerNumberMachine {
//程序运行时，只有一个客户型管理的机器，单例。
private static ServerNumberMachine instance;
/*
* 单例实现：构造方法私有，通过一个静态方法返回对象。
*/
private ServerNumberMachine(){}
public static ServerNumberMachine getInstance(){
if(instance == null){
synchronized(ServerNumberMachine.class){
if(instance == null){
instance = new ServerNumberMachine();
}
}
}
return instance;
}
/*
* 当服务窗口为客户服务时，客户管理机器要把该客户从等待服务的客户队列中移除。
*/
public String fetchCustomer(String name){
return ServerNumberQueue.valueOf(name).fetchNumber();
}
/*
* 添加客户到队列中
*/
public void generateCustomer(String name){
String mes;
mes = ServerNumberQueue.valueOf(name).generateNumber();
System.err.println("'" + mes + "'来了.");
}
}

     服务窗口(ServiceWindow)

public class ServiceWindow {
private String windowName;//服务窗口名
private String windowType;//服务窗口类型
private int windowNumber;//窗口号
private ServerNumberMachine snm;
private ExecutorService pool;

public ServiceWindow(int number) {
this(ConstantsUnit.COMMON_CUSTOMER, number);
}

public ServiceWindow(String type, int number) {
this.windowType = type;
this.windowName = type;
this.windowNumber = number;
this.snm = ServerNumberMachine.getInstance();
this.pool = ThreadPool.getInstance().getExecutorService();
}

public void setWindowName(String windowName) {
this.windowName = windowName;
}

public void setWindowNumber(int windowNumber) {
this.windowNumber = windowNumber;
}

public int getWindowNumber() {
return this.windowNumber;
}

private boolean service() {
return service(windowType);
}
/*
* 查找客户并为客户服务功能
*/
private boolean service(String type) {
/*try {
Thread.sleep(2000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}*/
Random time = new Random();
//当前服务窗口sleep时间，以模拟为客户服务耗时。当为快速客户服务时，时间为1；否则随机产生一个时间
int servicetime = type.equals(ConstantsUnit.FAST_CUSTOMER) ?
ConstantsUnit.MIN_SERVICE_TIME
: time.nextInt(ConstantsUnit.MAX_SERVICE_TIME
- ConstantsUnit.MIN_SERVICE_TIME)
+ ConstantsUnit.MIN_SERVICE_TIME + 1;
String servicemess;
servicemess = snm.fetchCustomer(type);
if (servicemess != null) {
try {
/*				System.out.println(windowName + windowNumber + "正在为'"
+ servicemess + "'服务");*/
long stime = System.currentTimeMillis();
Thread.sleep(servicetime);
long etime = System.currentTimeMillis();
System.out.println(windowName + windowNumber + "为'"
+ servicemess + "'服务完毕,耗时:" + (etime - stime) / 1000
+ "秒.");
return true;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/*		if(type.equals(ConstantsUnit.COMMON_CUSTOMER)){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}*/
return false;
}
/*
* 调用此方法让窗口开始服务
*   VIP，快速窗口没有相应的客户时，要服务普通客户
*/
public void startService() {
pool.execute(new Runnable() {
@Override
public void run() {
while (true) {
switch (windowType) {
/*
* VIP窗口成功为VIP客户服务则要继续判断是否有VIP客户等待服务，否则判断是否有等待服务的
*   普通客户，有则要为普通客户服务
*/
case "VIP":
if(service())//将查找客户并服务单独封装成一个方法，调用service方法
break;
service(ConstantsUnit.COMMON_CUSTOMER);
break;
/*
* 快速窗口成功为快速客户服务则要继续判断是否有VIP客户等待服务，否则判断是否有等待服务的
*   普通客户，有则要为普通客户服务
*/
case "FAST":
if(service())
break;
service(ConstantsUnit.COMMON_CUSTOMER);
break;
case "COMMON":
service();
}
}
}
});
}

}

     用到的一些常(ConstantsUnit)

public class ConstantsUnit {
public static int MAX_SERVICE_TIME = 10000;//最大服务时间，毫秒
public static int MIN_SERVICE_TIME = 1000;//最小服务时间
public static String VIP_CUSTOMER = "VIP";
public static String COMMON_CUSTOMER = "COMMON";
public static String FAST_CUSTOMER = "FAST";
public static int GENERATE_CUSTOMER = 1;//产生普通客户的时间间隔

}

     测试功能否完成(Test)

public class Test {
public static void main(String[] args){

final ServerNumberMachine snm = ServerNumberMachine.getInstance();

ThreadPool pool = ThreadPool.getInstance();

for(int i=1; i<=4; i++){
//			System.out.println("创建普通服务窗口...");
new ServiceWindow(i).startService();
}
//		System.out.println("创建快速服务窗口...");
new ServiceWindow(ConstantsUnit.FAST_CUSTOMER, 5).startService();
//		System.out.println("创建VIP服务窗口...");
new ServiceWindow(ConstantsUnit.VIP_CUSTOMER, 6).startService();

//产生普通客户
pool.getScheduledExecutorService().scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
snm.generateCustomer(ConstantsUnit.COMMON_CUSTOMER);
}
},
0,
ConstantsUnit.GENERATE_CUSTOMER,
TimeUnit.SECONDS);
//产生VIP客户
pool.getScheduledExecutorService().scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
snm.generateCustomer(ConstantsUnit.VIP_CUSTOMER);
}
},
0,
ConstantsUnit.GENERATE_CUSTOMER*6,
TimeUnit.SECONDS);
//产生快速客户
pool.getScheduledExecutorService().scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
snm.generateCustomer(ConstantsUnit.FAST_CUSTOMER);
}
},
0,
ConstantsUnit.GENERATE_CUSTOMER*2,
TimeUnit.SECONDS);
}

}

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------