银行业务调度系统面试题

题目要求:

银行业务调度系统

模拟实现银行业务调度系统逻辑,具体需求如下:
*银行内有6个业务窗口,1 – 4号窗口为普通窗口,5号窗口为快速窗口,6号窗口为VIP窗口。
*有三种对应类型的客户:VIP客户,普通客户,快速客户(办理如交水电费、电话费之类业务的客户)。
*异步随机生成各种类型的客户,生成各类型用户的概率比例为:
VIP客户 :普通客户 :快速客户  =  1 :6 :3。
*客户办理业务所需时间有最大值和最小值,在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间,
快速客户办理业务所需时间为最小值(提示:办理业务的过程可通过线程Sleep的方式模拟)。
*各类型客户在其对应窗口按顺序依次办理业务。
当VIP(6号)窗口和快速业务(5号)窗口没有客户等待办理业务的时候,这两个窗口可以处理普通客户的业务,
而一旦有对应的客户等待办理业务的时候,则优先处理对应客户的业务。
随机生成客户时间间隔以及业务办理时间最大值和最小值自定,可以设置。
不要求实现GUI,只考虑系统逻辑实现,可通过Log方式展现程序运行结果。

问题分析:

*有三种对应类型的客户:VIP客户,普通客户,快速客户 ,异步随机生成各种类型的客户,
各类型客户在其对应窗口按顺序依次办理业务 。
*首先,经常在银行办理业务的人更有利于理解本系统,每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。
所以,我想到要有一个号码管理器对象,让这个对象不断地产生号码,就等于随机生成了客户。
*由于有三类客户,每类客户的号码编排都是完全独立的,所以,我想到本系统一共要产生三个号码管理器对象,
各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理,
这个号码机器在整个系统中始终只能有一个,所以,它要被设计成单例。
*各类型客户在其对应窗口按顺序依次办理业务 ,准确地说,应该是窗口依次叫号。
*各个窗口怎么知道该叫哪一个号了呢?
它一定是问的相应的号码管理器,即服务窗口每次找号码管理器获取当前要被服务的号码。

关系结构分析图:

 

功能细分:

 

 

[java]
  1. “NumberManager”类    –>排号
  2.     定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。
  3.     定义一个产生新号码的方法和获取马上要为之服务的号码的方法,
  4.         这两个方法被不同的线程操作了相同的数据,所以,要进行同步。
  5. “NumberMachine”类    –>号码管理器,取号
  6.     定义三个成员变量分别指向三个NumberManager对象,分别表示普通、快速和VIP客户的号码管理器,
  7.     定义三个对应的方法来返回这三个NumberManager对象。
  8.     将NumberMachine类设计成单例。
  9. “CustomerType”枚举类
  10.     系统中有三种类型的客户,所以用定义一个枚举类,其中定义三个成员分别表示三种类型的客户。
  11.     重写toString方法,返回类型的中文名称。这是在后面编码时重构出来的,刚开始不用考虑。
  12. “ServiceWindow”类    –>业务窗口
  13.     定义一个start方法,内部启动一个线程,根据服务窗口的类别分别循环调用三个不同的方法。
  14.     定义三个方法分别对三种客户进行服务,为了观察运行效果,应详细打印出其中的细节信息。
  15. “MainClass”类
  16.     用for循环创建出4个普通窗口,再创建出1个快速窗口和一个VIP窗口。
  17.     接着再创建三个定时器,分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。
  18. “Constants”类
  19.     定义三个常量:MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

 

 

代码实现

NumberManager类

[java]
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. public class NumberManager {
  4.     private Integer lastNumber = 0;
  5.     private List<Integer> queueNumber = new ArrayList<Integer>();
  6.     public synchronized Integer generateNewManager(){   //号码排队
  7.         queueNumber.add(++lastNumber);//添加元素
  8.         return lastNumber;      //创建元素
  9.     }
  10.     public synchronized Integer fetchServiceNumber(){   //使用号码获取服务
  11.         if(queueNumber.size() >0)
  12.             return queueNumber.remove(0);//remove返回值为该角标上元素
  13.         else
  14.             return null;
  15.     }
  16. }

 

NumberMechine类

取票机

 

[java]
  1. public class NumberMachine {
  2.     private NumberMachine(){};  //单例模式,只有一个取票机
  3.     private static NumberMachine instance = new NumberMachine();
  4.     public static NumberMachine getInstance(){
  5.         return instance;
  6.     }
  7.     //取票机中有三种票,对应各自的取出方法
  8.     private NumberManager commonManager = new NumberManager();
  9.     private NumberManager expressManager = new NumberManager();
  10.     private NumberManager vipManager = new NumberManager();
  11.     public NumberManager getCommonManager() {
  12.         return commonManager;
  13.     }
  14.     public NumberManager getExpressManager() {
  15.         return expressManager;
  16.     }
  17.     public NumberManager getVipManager() {
  18.         return vipManager;
  19.     }
  20. }

 

 

CustomerType枚举类

 

客户类型

[java]
  1. public enum CustomerType {
  2.     COMMON,EXPRESS,VIP;
  3.     public String toString(){   //switch 接收类型为int 或 Enum 类型
  4.         switch(this){
  5.         case COMMON:
  6.             return “普通”;
  7.         case EXPRESS:
  8.             return “快速”;
  9.         }
  10.         return “VIP”;
  11.     }
  12. }

 

 

Constants常量类

 

 

 

[java]
  1. public class Constants {    //常量
  2.     public final static int Max_Service_Time = 10000;
  3.     public final static int Min_Service_Time = 1000;
  4.     public final static int Common_Customer_Interval_Time = 1;
  5. }

 

 

ServiceWindow类 业务调度窗口(核心)

 

 

 

[java]
  1. package com.itheima;
  2. import java.util.Random;
  3. import java.util.concurrent.Executors;
  4. public class ServiceWindow {
  5.     private CustomerType type = CustomerType.COMMON;//客户类型
  6.     private int windowId = 1;   //窗口号码
  7.     public CustomerType getType(){
  8.         return type;
  9.     }
  10.     public void setType(CustomerType type) {
  11.         this.type = type;
  12.     }
  13.     public void setWindowId(int windowId) {
  14.         this.windowId = windowId;
  15.     }
  16.     public void start(){    //线程池执行任务
  17.         Executors.newSingleThreadExecutor().execute(new Runnable(){ //匿名内部类
  18.             public void run(){
  19.                 while(true){
  20.                     switch(type){   //switch参数可以是int或 Enum
  21.                     case COMMON:
  22.                         commonService();
  23.                         break;
  24.                     case EXPRESS:
  25.                         expressService();
  26.                         break;
  27.                     case VIP:
  28.                         vipService();
  29.                         break;
  30.                     }
  31.                 }
  32.             }
  33.         });
  34.     }
  35.         //普通客户
  36.         private void commonService() {
  37.             String windowName = windowId + “号” + type +”窗口”;
  38.             System.out.println(windowName+”正在获取任务…”);
  39.             Integer number = NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
  40.             if(number !=null){
  41.                 int maxRandom = Constants.Max_Service_Time – Constants.Min_Service_Time;
  42.                 long serverTime = new Random().nextInt(maxRandom)+1+Constants.Min_Service_Time;
  43.                 try {
  44.                     Thread.sleep(serverTime);   //服务时间
  45.                 } catch (InterruptedException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.                 System.out.println(windowName + “完成为第” +number+”个普通客户服务;耗时: “+serverTime+” Millis”);
  49.             }
  50.             else{
  51.                 System.out.println(windowName+”没有任务…休息1秒钟…”);
  52.                 try {
  53.                     Thread.sleep(1000);         //等待时间
  54.                 } catch (InterruptedException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.         }
  59.         //VIP客户
  60.         private void vipService() {
  61.             String windowName = windowId + “号” + type +”窗口”;
  62.             System.out.println(windowName+”正在获取任务…”);
  63.             Integer number = NumberMachine.getInstance().getVipManager().fetchServiceNumber();
  64.             if(number !=null){
  65.                 int maxRandom = Constants.Max_Service_Time – Constants.Min_Service_Time;
  66.                 long serverTime = new Random().nextInt(maxRandom)+1+Constants.Min_Service_Time;
  67.                 try {
  68.                     Thread.sleep(serverTime);   //服务时间
  69.                 } catch (InterruptedException e) {
  70.                     e.printStackTrace();
  71.                 }
  72.                 System.out.println(windowName + “完成为第” +number+”个”+type+”客户服务;耗时: “+serverTime+” Millis”);
  73.             }
  74.             else{
  75.                 System.out.println(windowName+”没有任务…休息1秒钟…”);
  76.                 commonService();    //为普通客户服务
  77.                 try {
  78.                     Thread.sleep(1000);         //等待时间
  79.                 } catch (InterruptedException e) {
  80.                     e.printStackTrace();
  81.                 }
  82.             }
  83.         }
  84.         private void expressService() {
  85.             String windowName = windowId + “号” + type +”窗口”;
  86.             System.out.println(windowName+”正在获取任务…”);
  87.             Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
  88.             if(number !=null){
  89.                 int serviceTime = Constants.Min_Service_Time;
  90.                 try {
  91.                     Thread.sleep(serviceTime);  //快速客户服务时间,最小值
  92.                 } catch (InterruptedException e) {
  93.                     e.printStackTrace();
  94.                 }
  95.                 System.out.println(windowName + “完成为第” +number+”个”+type+”客户服务;耗时: “+serviceTime+” Millis”);
  96.             }
  97.             else{
  98.                 System.out.println(windowName+”没有任务…休息1秒钟…”);
  99.                 commonService();    //为普通客户服务
  100.                 try {
  101.                     Thread.sleep(1000);         //等待时间
  102.                 } catch (InterruptedException e) {
  103.                     e.printStackTrace();
  104.                 }
  105.             }
  106.         }
  107. }

 

 

MainClass 用于测试

 

 

 

[java]
  1. package com.itheima;
  2. import java.util.concurrent.Executors;
  3. import java.util.concurrent.TimeUnit;
  4. public class MainClass {
  5.     /**
  6.      * @param args
  7.      */
  8.     public static void main(String[] args) {
  9.         //产生四个普通窗口
  10.         for(int i=1; i<5 ;i++){
  11.             ServiceWindow commonWindow = new ServiceWindow();
  12.             commonWindow.setWindowId(i);
  13.             commonWindow.start();
  14.         }
  15.         //产生一个VIP窗口
  16.         ServiceWindow expressWindow = new ServiceWindow();
  17.         expressWindow.setType(CustomerType.VIP);    //设置客户类型VIP
  18.         expressWindow.start();
  19.         //产生一个快速窗口
  20.         ServiceWindow vipWindow = new ServiceWindow();
  21.         vipWindow.setType(CustomerType.EXPRESS);    //设置客户类型 快速
  22.         vipWindow.start();
  23.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
  24.                 new Runnable(){         //匿名内部类
  25.                     public void run(){  //普通客户
  26.                         Integer number = NumberMachine.getInstance().getCommonManager().generateNewManager();
  27.                         System.out.println(number + “号普通客户等待服务”);
  28.                     }
  29.                 },
  30.                 0,
  31.                 Constants.Common_Customer_Interval_Time,
  32.                 TimeUnit.SECONDS);
  33.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
  34.                 new Runnable(){
  35.                     public void run(){  //快速客户
  36.                         Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();
  37.                         System.out.println(number + “号快速客户等待服务”);
  38.                     }
  39.                 },
  40.                 0,
  41.                 Constants.Common_Customer_Interval_Time*2,
  42.                 TimeUnit.SECONDS);
  43.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
  44.                 new Runnable(){
  45.                     public void run(){  //VIP客户
  46.                         Integer number = NumberMachine.getInstance().getVipManager().generateNewManager();
  47.                         System.out.println(number + “号VIP客户等待服务”);
  48.                     }
  49.                 },
  50.                 0,
  51.                 Constants.Common_Customer_Interval_Time*6,
  52.                 TimeUnit.SECONDS);
  53.     }
  54. }

运行结果:

 

 

 

另附:”关于switch的参数类型”

switch(expr)中,expr是一个整数表达式,整数表达式可以是int基本类型或Integer包装类型,
由于,byte,short,char交给 switch 处理时自动转成了int,所以,这些类型以及这些类型的包装类型也是可以的。
因此传递给 switch 和case 语句的参数应该是 int、 short、 char 或者 byte,还有 Enum
long,string 由于不能直接转成 int 所以不能作用于swtich。在jdk 1.7中switch的参数类型可以是字符串类型。

标签