银行业务调度系统
今天在网上看到一道关于银行业务调度系统的题目，感觉有点意思，就动手写了写代码，记录一下。
题目：
模拟实现银行业务调度系统逻辑，具体需求如下：
*银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
*有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。
*异步随机生成各种类型的客户，生成各类型用户的概率比例为：
VIP客户 ：普通客户 ：快速客户 = 1 ：6 ：3。
*客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，
快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。
*各类型客户在其对应窗口按顺序依次办理业务。
当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，
而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。
不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。
对题目进行分析，
有三种类型的客户，他们的身份（职责）并不相同，但是他们的方法确实相同的，所以定义了三个方法相同的接口IVIPCustom,IExpressCustom和ICommonCustom。
package com.garychow.interfaces;
public interface IVIPCustom {
public int getNeedsTime();
public String getName();
}
package com.garychow.interfaces;
public interface IExpressCustom {
public int getNeedsTime();
public String getName();
}
package com.garychow.interfaces;
public interface ICommonCustom {
public int getNeedsTime();
public String getName();
}
三类客户分别对应了三种职责的窗口，普通窗口，快速窗口和VIP窗口。所以，也需要三个接口，ICommonServiceWindow,IExpressServiceWindow和IVIPServiceWindow。
package com.garychow.interfaces;
public interface ICommonServiceWindow {
public boolean service(ICommonCustom custom);
}
package com.garychow.interfaces;
public interface IExpressServiceWindow {
public boolean service(IExpressCustom custom);
}
package com.garychow.interfaces;
public interface IVIPServiceWindow {
public boolean service(IVIPCustom custom);
}
最后，有一个调度业务窗口和用户的系统，同时根据题意，是通过号码来进行管理调度的，我把他们的职责归纳到一起，所以有一个INumberMachine接口。
package com.garychow.interfaces;
// INumberMachine是整个系统的调度类，负责管理维护和处理服务顺序等
public interface INumberMachine {
// 产生一个普通客户
public void generateCommonCustom();
// 产生一个VIP客户
public void generateVIPCustom();
// 产生一个快速客户
public void generateExpressCustom();
// 为下一个普通客户服务
public void serviceNextCommonCustom();
// 为下一个VIP客户服务
public void serviceNextVIPCustom();
// 为下一个快速客户服务
public void serviceNextExpressCustom();
}
接口声明到此就结束了。
现在需要来考虑具体实现了：
首先需要定义常量：
package com.garychow.classes;
public class Constants {
public static final int GENERATE_INTERVAL_TIME = 1;
public static final int CUSTOM_NEEDS_TIME_MAX = 6;
public static final int CUSTOM_NEEDS_TIME_MIN = 2;
}
然后需要实现ICommonCustom，IExpressCustom和IVIPCustom接口。
package com.garychow.classes;
import com.garychow.interfaces.ICommonCustom;
public class CommonCustom implements ICommonCustom {
@Override
public int getNeedsTime() {
return time;
}
@Override
public String getName() {
return name;
}
private int time = (int)((Math.random() * (Constants.CUSTOM_NEEDS_TIME_MAX - Constants.CUSTOM_NEEDS_TIME_MIN)
+ Constants.CUSTOM_NEEDS_TIME_MIN) * 1000);
private String name = ++number + "号普通客户";
private static int number = 0;
}
package com.garychow.classes;
import com.garychow.interfaces.IVIPCustom;
public class VIPCustom implements IVIPCustom {
@Override
public int getNeedsTime() {
return time;
}
@Override
public String getName() {
return name;
}
private int time = (int)((Math.random() * (Constants.CUSTOM_NEEDS_TIME_MAX - Constants.CUSTOM_NEEDS_TIME_MIN)
+ Constants.CUSTOM_NEEDS_TIME_MIN) * 1000);
private String name = ++number + "号VIP客户";
private static int number = 0;
}
package com.garychow.classes;
import com.garychow.interfaces.IExpressCustom;
public class ExpressCustom implements IExpressCustom {
@Override
public int getNeedsTime() {
return time;
}
@Override
public String getName() {
return name;
}
private int time = (Constants.CUSTOM_NEEDS_TIME_MIN * 1000);
private String name = ++number + "号快速顾客";
private static int number = 0;
}
普通客户可以由任意一个窗口服务，而VIP客户和快速客户只能通过相应的窗口获得服务，因为，我认为这个可以设计为一个责任链，把普通客户交给链头，直到有窗口能服务客户或者都暂时不能服务为止。因为设计一个抽象类AResponsibilityChainCommonWindow实现ICommonServiceWindow接口。
package com.garychow.classes;
import com.garychow.interfaces.ICommonCustom;
import com.garychow.interfaces.ICommonServiceWindow;
public abstract class AResponsibilityChainCommonWindow implements ICommonServiceWindow {
private ICommonServiceWindow nextCommonServiceWindow;
public ICommonServiceWindow getNextCommonServiceWindow() {
return nextCommonServiceWindow;
}
public void setNextCommonServiceWindow(ICommonServiceWindow nextCommonServiceWindow) {
this.nextCommonServiceWindow = nextCommonServiceWindow;
}
@Override
public boolean service(ICommonCustom custom) {
if (null != nextCommonServiceWindow) {
return nextCommonServiceWindow.service(custom);
}
return false;
}
}
责任链已经搞定了，现在发现调度系统需要了解各个窗口的状态，好分配客户到窗口去。这是一个典型的观察者，而窗口们就是被观察者。因为实现一个观察者类WindowObserver，由它去通知INumberMachine。
package com.garychow.classes;
import com.garychow.interfaces.INumberMachine;
public class WindowObserver {
public static WindowObserver getInstance() {
return WindowObserverHolder.wo;
}
private static class WindowObserverHolder {
public static final WindowObserver wo = new WindowObserver();
}
private WindowObserver() {
}
public void commonWindowServiceFinish() {
nm.serviceNextCommonCustom();
}
public void vipWindowServiceFinish() {
nm.serviceNextVIPCustom();
}
public void expressWindowServiceFinish() {
nm.serviceNextExpressCustom();
}
private INumberMachine nm = NumberMachine.getInstance();
}
到这里整体的思路全部都清晰了，下面只要把方法都实现出来就好了。
类CommonWindow继承AResponsibilityChainCommonWindow，实现服务客户的方法。
package com.garychow.classes;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import com.garychow.interfaces.ICommonCustom;
public class CommonWindow extends AResponsibilityChainCommonWindow {
public CommonWindow(String name) {
this.name = name;
}
@Override
public boolean service(ICommonCustom custom) {
if (isServicing) {
return super.service(custom);
}
isServicing = true;
final ICommonCustom fCustom = custom;
executor.execute(new Runnable() {
@Override
public void run() {
try {
long beginTime = System.nanoTime();
System.out.println(name + "开始为普通顾客：" + fCustom.getName() + "服务");
Thread.sleep(fCustom.getNeedsTime());
long endTime = System.nanoTime();
System.out.println(name + "服务顾客" + fCustom.getName() + "完毕，服务时间为:" + (endTime - beginTime));
} catch (InterruptedException e) {
} finally {
isServicing = false;
WindowObserver.getInstance().commonWindowServiceFinish();
}
}
});
return true;
}
private Executor executor = Executors.newSingleThreadExecutor();
private boolean isServicing;
private String name;
}
VIPServiceWindow也继承AResponsibilityChainCommonWindow类，因为它也是处理普通客户的链上的一环，同时要实现IVIPServiceWindow接口，处理VIP客户服务。
package com.garychow.classes;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import com.garychow.interfaces.ICommonCustom;
import com.garychow.interfaces.IVIPCustom;
import com.garychow.interfaces.IVIPServiceWindow;
public class VIPServiceWindow extends AResponsibilityChainCommonWindow implements IVIPServiceWindow {
public VIPServiceWindow(String name) {
this.name = name;
}
@Override
public boolean service(ICommonCustom custom) {
if (isServicing) {
return super.service(custom);
}
isServicing = true;
final ICommonCustom fCustom = custom;
executor.execute(new Runnable() {
@Override
public void run() {
try {
long beginTime = System.nanoTime();
System.out.println(name + "开始为普通顾客：" + fCustom.getName() + "服务");
Thread.sleep(fCustom.getNeedsTime());
long endTime = System.nanoTime();
System.out.println(name + "服务顾客" + fCustom.getName() + "完毕，服务时间为:" + (endTime - beginTime));
} catch (InterruptedException e) {
} finally {
isServicing = false;
WindowObserver.getInstance().commonWindowServiceFinish();
}
}
});
return true;
}
@Override
public boolean service(IVIPCustom custom) {
if (isServicing) {
return false;
}
isServicing = true;
final IVIPCustom fCustom = custom;
executor.execute(new Runnable() {
@Override
public void run() {
try {
long beginTime = System.nanoTime();
System.out.println(name + "开始为VIP顾客：" + fCustom.getName() + "服务");
Thread.sleep(fCustom.getNeedsTime());
long endTime = System.nanoTime();
System.out.println(name + "服务顾客" + fCustom.getName() + "完毕，服务时间为:" + (endTime - beginTime));
} catch (InterruptedException e) {
} finally {
isServicing = false;
WindowObserver.getInstance().vipWindowServiceFinish();
}
}
});
return true;
}
private Executor executor = Executors.newSingleThreadExecutor();
private boolean isServicing;
private String name;
}
同样的，ExpressServiceWindow和VIPServiceWdinow类似。
package com.garychow.classes;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import com.garychow.interfaces.ICommonCustom;
import com.garychow.interfaces.IExpressCustom;
import com.garychow.interfaces.IExpressServiceWindow;
public class ExpressServiceWindow extends AResponsibilityChainCommonWindow
implements IExpressServiceWindow {
public ExpressServiceWindow(String name) {
this.name = name;
}
@Override
public boolean service(IExpressCustom custom) {
if (isServicing) {
return false;
}
isServicing = true;
final IExpressCustom fCustom = custom;
executor.execute(new Runnable() {
@Override
public void run() {
try {
long beginTime = System.nanoTime();
System.out.println(name + "开始为快速顾客：" + fCustom.getName() + "服务");
Thread.sleep(fCustom.getNeedsTime());
long endTime = System.nanoTime();
System.out.println(name + "服务顾客" + fCustom.getName() + "完毕，服务时间为:" + (endTime - beginTime));
} catch (InterruptedException e) {
} finally {
isServicing = false;
WindowObserver.getInstance().expressWindowServiceFinish();
}
}
});
return true;
}
@Override
public boolean service(ICommonCustom custom) {
if (isServicing) {
return super.service(custom);
}
isServicing = true;
final ICommonCustom fCustom = custom;
executor.execute(new Runnable() {
@Override
public void run() {
try {
long beginTime = System.nanoTime();
System.out.println(name + "开始为普通顾客：" + fCustom.getName() + "服务");
Thread.sleep(fCustom.getNeedsTime());
long endTime = System.nanoTime();
System.out.println(name + "服务顾客" + fCustom.getName() + "完毕，服务时间为:" + (endTime - beginTime));
} catch (InterruptedException e) {
} finally {
isServicing = false;
WindowObserver.getInstance().commonWindowServiceFinish();
}
}
});
return true;
}
private Executor executor = Executors.newSingleThreadExecutor();
private boolean isServicing;
private String name;
}
写到这里，只需要把调度系统给实现就好了。代码如下：
package com.garychow.classes;
import java.util.Queue;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import com.garychow.interfaces.ICommonCustom;
import com.garychow.interfaces.ICommonServiceWindow;
import com.garychow.interfaces.IExpressCustom;
import com.garychow.interfaces.IExpressServiceWindow;
import com.garychow.interfaces.INumberMachine;
import com.garychow.interfaces.IVIPCustom;
import com.garychow.interfaces.IVIPServiceWindow;
public class NumberMachine implements INumberMachine {
private static class NumberMachineHolder {
public final static NumberMachine nm = new NumberMachine();
}
private NumberMachine() {
executor = Executors.newSingleThreadExecutor();
commonCustoms = new LinkedBlockingQueue<ICommonCustom>();
vipCustoms = new LinkedBlockingQueue<IVIPCustom>();
expressCustoms = new LinkedBlockingQueue<IExpressCustom>();
AResponsibilityChainCommonWindow cw1 = new CommonWindow("一号普通窗口");
AResponsibilityChainCommonWindow cw2 = new CommonWindow("二号普通窗口");
AResponsibilityChainCommonWindow cw3 = new CommonWindow("三号普通窗口");
AResponsibilityChainCommonWindow cw4 = new CommonWindow("四号普通窗口");
VIPServiceWindow vw = new VIPServiceWindow("VIP窗口");
ExpressServiceWindow ew = new ExpressServiceWindow("快速窗口");
cw1.setNextCommonServiceWindow(cw2);
cw2.setNextCommonServiceWindow(cw3);
cw3.setNextCommonServiceWindow(cw4);
cw4.setNextCommonServiceWindow(ew);
ew.setNextCommonServiceWindow(vw);
commonServiceWindowChainHeader = cw1;
expressServiceWindow = ew;
vipServiceWindow = vw;
}
public static INumberMachine getInstance() {
return NumberMachineHolder.nm;
}
@Override
public void generateCommonCustom() {
ICommonCustom custom = new CommonCustom();
commonCustoms.offer(custom);
serviceNextCommonCustom();
}
@Override
public void generateVIPCustom() {
IVIPCustom custom = new VIPCustom();
vipCustoms.offer(custom);
serviceNextVIPCustom();
}
@Override
public void generateExpressCustom() {
IExpressCustom custom = new ExpressCustom();
expressCustoms.offer(custom);
serviceNextExpressCustom();
}
@Override
public void serviceNextCommonCustom() {
executor.execute(new Runnable() {
@Override
public void run() {
serviceNextCommonCustom(commonServiceWindowChainHeader);
}
});
}
@Override
public void serviceNextVIPCustom() {
executor.execute(new Runnable() {
@Override
public void run() {
if (!serviceNextVIPCustom(vipServiceWindow)) {
serviceNextCommonCustom(vipServiceWindow);
}
}
});
}
@Override
public void serviceNextExpressCustom() {
executor.execute(new Runnable() {
@Override
public void run() {
if (!serviceNextExpressCustom(expressServiceWindow)) {
serviceNextCommonCustom(expressServiceWindow);
}
}
});
}
private boolean serviceNextCommonCustom(ICommonServiceWindow window) {
boolean isServiced = false;
if (!commonCustoms.isEmpty()) {
ICommonCustom custom = commonCustoms.element();
if (isServiced = window.service(custom)) {
commonCustoms.poll();
}
}
return isServiced;
}
private boolean serviceNextExpressCustom(IExpressServiceWindow window) {
boolean isServiced = false;
if (!expressCustoms.isEmpty()) {
IExpressCustom custom = expressCustoms.element();
if (isServiced = window.service(custom)) {
expressCustoms.poll();
}
}
return isServiced;
}
private boolean serviceNextVIPCustom(IVIPServiceWindow window) {
boolean isServiced = false;
if (!vipCustoms.isEmpty()) {
IVIPCustom custom = vipCustoms.element();
if (isServiced = window.service(custom)) {
vipCustoms.poll();
}
}
return isServiced;
}
private final Executor executor;
private final Queue<ICommonCustom> commonCustoms;
private final Queue<IVIPCustom> vipCustoms;
private final Queue<IExpressCustom> expressCustoms;
private final AResponsibilityChainCommonWindow commonServiceWindowChainHeader;
private final ExpressServiceWindow expressServiceWindow;
private final VIPServiceWindow vipServiceWindow;
}
最后，写出场景类调用就可以模拟银行调度系统了。
package com.garychow.classes;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.garychow.interfaces.INumberMachine;
public class Context {
public static void main(String[] args) {
final INumberMachine nm = NumberMachine.getInstance();
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
double random = Math.random();
if (random < 0.1) {
nm.generateVIPCustom();
} else if (random >= 0.1 && random < 0.4) {
nm.generateExpressCustom();
} else {
nm.generateCommonCustom();
}
}
}, 0, Constants.GENERATE_INTERVAL_TIME, TimeUnit.SECONDS);
}
}
到此，这个题目就算完全做完了。