模拟实现银行业务调度系统逻辑,具体需求如下:
Ø 银行内有6个业务窗口,1- 4号窗口为普通窗口,5号窗口为快速窗口,6号窗口为VIP窗口。
Ø 有三种对应类型的客户:VIP客户,普通客户,快速客户(办理如交水电费、电话费之类业务的客户)。
Ø 异步随机生成各种类型的客户,生成各类型用户的概率比例为:
VIP客户 :普通客户 :快速客户 = 1 :6 :3。
Ø 客户办理业务所需时间有最大值和最小值,在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间,快速客户办理业务所需时间为最小值(提示:办理业务的过程可通过线程Sleep的方式模拟)。
Ø 各类型客户在其对应窗口按顺序依次办理业务。
Ø 当VIP(6号)窗口和快速业务(5号)窗口没有客户等待办理业务的时候,这两个窗口可以处理普通客户的业务,而一旦有对应的客户等待办理业务的时候,则优先处理对应客户的业务。
Ø 随机生成客户时间间隔以及业务办理时间最大值和最小值自定,可以设置。
Ø 不要求实现GUI,只考虑系统逻辑实现,可通过Log方式展现程序运行结果。
类图:
面向对象的设计分析
NumberManager
客户分为3种,每一种号码生成器都是独立的,并且可以生成,和取出号码的方法。而这两个方法被不同的线程操作了相同的数据,所以要进行同步。
import java.util.ArrayList;
import java.util.List;
public class NumberManeger {
private int number=0;
private List<Integer> numberManager=new ArrayList<Integer>();
public synchronized Integer generateNumber(){
numberManager.add(++number);
return number;
}
public synchronized Integer getNumber(){
Integer num=null;
if(numberManager.size()>0)
num=numberManager.remove(0);
return num;
}
NumberMachine
分别创建三种号码管理器对象,并且对外暴露获取方法,NumberMachine要设计成单例
public class NumberMachine {
private NumberMachine(){}
private static NumberMachine Instance=new NumberMachine();
public static NumberMachine getInstance(){
return Instance;
}
private NumberManeger conmonManager=new NumberManeger();
private NumberManeger expressManager=new NumberManeger();
private NumberManeger VIPManager=new NumberManeger();
public NumberManeger getConmonManager() {
return conmonManager;
}
public NumberManeger getExpressManager() {
return expressManager;
}
public NumberManeger getVIPManager() {
return VIPManager;
}
}
客户类型用枚举表示:
public enum CustomType {
CONMON,EXPRESS,VIP;
@Override
public String toString(){
switch(this){
case CONMON:
return "普通";
case EXPRESS:
return "快速";
case VIP:
return name();
}
return null;
}
}
ServiceWindow
定义一个start方法,内部启动一个线程,根据服务窗口的种类分别循环调用3种不同的方法。方法中分别对三种客户进行服务,观察运行效果。
import java.util.Random;
import java.util.concurrent.Executors;
public class ServiceWindow {
private CustomType type=CustomType.CONMON;//默认每个窗口都是普通的
private int number=1;
//窗口编号
public void setNumber(int number) {
this.number = number;
}
//客户类型
public void setType(CustomType type) {
this.type = type;
}
public void start(){
Executors.newSingleThreadExecutor().execute(new Runnable(){
public void run(){
//无限循环,执行服务代码。这里使用switch,高效。
while(true){
switch(type){
case CONMON:
conmonService();
break;
case EXPRESS:
expressService();
break;
case VIP:
VIPService();
break;
}
}
}
});
}
public void conmonService() {
String windowName="第"+number+"号"+type+"窗口";
Integer serviceNumber= NumberMachine.getInstance().getConmonManager().getNumber();
System.out.println(windowName+"开始获取普通任务");
if(serviceNumber!=null){
System.out.println(windowName+"开始为"+serviceNumber+"普通客户服务");
int maxRan=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
int serviceTime=new Random().nextInt(maxRan)+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+"没有任务空闲1秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void expressService() {
String windowName="第"+number+"号"+type+"窗口";
Integer serviceNumber= NumberMachine.getInstance().getExpressManager().getNumber();
System.out.println(windowName+"开始获取快速任务");
if(serviceNumber!=null){
System.out.println(windowName+"开始为"+serviceNumber+"快速客户服务");
int maxRan=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
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+"没有任务空闲");
//无任务时,调用普通服务方法,访问共享数据
conmonService();
}
}
public void VIPService() {
String windowName="第"+number+"号"+type+"窗口";
Integer serviceNumber= NumberMachine.getInstance().getVIPManager().getNumber();
System.out.println(windowName+"开始获取VIP任务");
if(serviceNumber!=null){
System.out.println(windowName+"开始为"+serviceNumber+"VIP客户服务");
int maxRan=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
int serviceTime=Constants.MAX_SERVICE_TIME;
try {
Thread.sleep(serviceTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(windowName+"为第"+serviceNumber+"VIP顾客服务完毕耗时"+serviceTime/1000+"秒");
}
else{
System.out.println(windowName+"没有任务");
conmonService();
}
}
}
定义一个常量类。存储服务的最大时间和最小时间,还有普通客户的生成时间。
public class Constants {
public static int MAX_SERVICE_TIME=10000;
public static int MIN_SERVICE_TIME=1000;
public static int CONMON_SERVICE_TIME=1;
}
MainClass
创建3种服务窗口,4个普通,一个快速,一个VIP。定义3个计时器分别以6:3:1的时间间隔生成3种不同客户,模拟客户请求服务。
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class MainClass {
public static void main(String[] args) {
for(int x=1;x<5;x++){
ServiceWindow window=new ServiceWindow();
window.setNumber(x);
window.start();
}
ServiceWindow expressWindow=new ServiceWindow();
expressWindow.setType(CustomType.EXPRESS);
expressWindow.start();
ServiceWindow VIPWindow=new ServiceWindow();
VIPWindow.setType(CustomType.VIP);
VIPWindow.start();
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
public void run(){
Integer number=NumberMachine.getInstance().getConmonManager().generateNumber();
System.out.println("第"+number+"普通客户等待服务");
}
},
0,
Constants.CONMON_SERVICE_TIME,
TimeUnit.SECONDS);
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
public void run(){
Integer number=NumberMachine.getInstance().getExpressManager().generateNumber();
System.out.println("第"+number+"快速客户等待服务");
}
},
0,
Constants.CONMON_SERVICE_TIME *2,
TimeUnit.SECONDS);
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
public void run(){
Integer number=NumberMachine.getInstance().getVIPManager().generateNumber();
System.out.println("第"+number+"VIP客户等待服务");
}
},
0,
Constants.CONMON_SERVICE_TIME *6,
TimeUnit.SECONDS);
}
}