黑马训练营——银行调度系统

 

模拟实现银行业务调度系统逻辑

需求分析：

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

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

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

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

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

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

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

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

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

 

 

 面向对象分析和设计：

 1.有三种对应类型的客户：VIP客户，普通客户，快速客户 ，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务 首先，经常在银行办理业务的人更有利于理解本系统，每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以，要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。由于有三类客户，每类客户的号码编排都是完全独立的，所以，本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

 

2. 各类型客户在其对应窗口按顺序依次办理业务 ，准确地说，应该是窗口依次叫号。

各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

 

代码的实现

 // 功能：
 // 1.新客户拿号，产生新号码
 // 2.服务窗口取号（已经产生的客户号）
 public class NumberManager {
    private int lastNumber = 1;
    private List<Integer> quenueNumber = new ArrayList<Integer>();
 
    //产生一个新号码（新客户）
    public synchronized Integer generateNewManager(){ //加上同步 一次只允许一个线程访问
       quenueNumber.add(lastNumber);
       return lastNumber++;
    }
 
    //窗口取服务的号
    public synchronized Integer fetchServiceNumber(){
       Integer number = null;
       if(quenueNumber.size()>0){
          number = quenueNumber.remove(0); //移除 列表头的元素，并返回该元素
       }
       return number; 
    }
}
 
取号码机机类（NumberMachine ）：负责给不同客户派号 
 // 号码机器类（单例）
 // 功能：
 // 1.新客户拿号，产生新号码
 // 2.服务窗口取号（已经产生的客户号）

public class NumberMachine {
   //1.创建一个普通对象
   //创建三个号码管理对象，分别存放不同类型的号码。
   //并分别向外提供获取号码的属性（方法）。
   private NumberManager commoManager = new NumberManager();
   private NumberManager expressManager = new NumberManager();
   private NumberManager vipManager = new NumberManager();
 
   public NumberManager getCommoManager() {
      return commoManager;
   }
   public NumberManager getExpressManager() {
      return expressManager;
   }
   public NumberManager getVipManager() {
      return vipManager;
   }
 
   //2.把该对象设计为单例
   private NumberMachine(){}
 
   private static NumberMachine instance = new NumberMachine(); 
   public static NumberMachine getInstance(){
      return instance;
   }                                            
}
 
窗口服务类（ServiceWindow ）：负责为客户服务
 // 成员：
 // 窗口id  -->设置窗口id属性（方法）
 // 服务的客户类型  -->设置客户类型属性（方法）
 // 功能：
 // 1.开始服务方法

 public class ServiceWindow {
    private CustomerType type =CustomerType.COMMON;
    private int windowId=1;
    public void setType(CustomerType type) {
       this.type = type;
    }
    public void setWindowId(int windowId) {
       this.windowId = windowId;
    }
 
    public void start(){
       Executors.newSingleThreadExecutor().execute(
          new Runnable(){
              public void run() {
                 while(true){
      //switch比if...else效率高
      // switch(key)的key只能是一个整数表达式或者枚举常量，整数表达式可以是int基本类型或Integer包装类型，
      // 由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。
      // 显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中
      // 枚举：值是int类型，一般用它的名称表示。
                    switch (type) {
                    case COMMON: //或者：CustomerType.COMMON
                       commonService();
                       break;
                    case EXPRESS:
                       expressService();
                       break;
                    case VIP:
                       vipService();
                       break;
                    }
                 }    
              }   
          });
    }
    private void commonService() {
       String windowName = "第"+windowId+"号"+type+"窗口";
       //System.out.println(windowName+"正在获取任务");
       //fetchServiceNumber阻塞式方法
       Integer number = NumberMachine.getInstance().getCommoManager().fetchServiceNumber();
       System.out.println(windowName+"正在获取普通任务"); //该打印语句放这里，避免阻塞方法隔断和下面打印的连贯性。
       if(number!=null){
          System.out.println(windowName+"正在为第"+number+"号普通客户服务");
          long beginTime = System.currentTimeMillis();
          int maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
          long serverTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME; //1千到1万毫秒
          try {
             Thread.sleep(serverTime);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
          long costTime = System.currentTimeMillis()- beginTime;
          System.out.println(windowName+"为第"+number+"号普通客户完成服务，耗时"+costTime/1000+"秒");
   
       }else {
          System.out.println(windowName+"没有取到普通任务，先休息1秒");
          try {
             Thread.sleep(1000);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
       }
    }
 
    private void expressService() {
       String windowName = "第"+windowId+"号"+type+"窗口";
       Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
       System.out.println(windowName+"正在获取快速任务");
       if(number!=null){
          System.out.println(windowName+"正在为第"+number+"号"+type+"客户服务");
          long beginTime = System.currentTimeMillis();
          //int maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
          //long serverTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME; //1千到1万毫秒
          try {
             Thread.sleep(Constants.MIN_SERVICE_TIME);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
          long costTime = System.currentTimeMillis()- beginTime;
          System.out.println(windowName+"为第"+number+"号"+type+"客户完成服务，耗时"+costTime/1000+"秒");
       }else {
          System.out.println(windowName+"没有取到快速任务");
          commonService();
       }
    }
 
    private void vipService() {
       String windowName = "第"+windowId+"号"+type+"窗口";
       Integer number = NumberMachine.getInstance().getVipManager().fetchServiceNumber();
       System.out.println(windowName+"正在获取VIP任务");
       if(number!=null){
          System.out.println(windowName+"正在为第"+number+"号"+type+"客户服务");
          long beginTime = System.currentTimeMillis();
          int maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
          long serverTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME; //1千到1万毫秒
          try {
             Thread.sleep(serverTime);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
          long costTime = System.currentTimeMillis()- beginTime;
          System.out.println(windowName+"为第"+number+"号"+type+"客户完成服务，耗时"+costTime/1000+"秒");  
       }else {
          System.out.println(windowName+"没有取到VIP任务");
          commonService();
       }
    }
 }
 
Constants 类
public class Constants {
   public static int MAX_SERVICE_TIME = 10000;
   public static int MIN_SERVICE_TIME = 1000;
   //每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
   //平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以，
   //1秒钟产生一个普通客户比较合理，
   public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;
}
 
CustomerType 枚举 
public enum CustomerType {
   COMMON,EXPRESS,VIP;
   //重写toString方法
   public String toString(){
      switch(this){
         case COMMON:
             return "普通";
         case EXPRESS:
             return "快速";
         case VIP:
             return name();
      }
      return null;
   }
}
 
主类（MainClass）：启动服务
public class MainClass{
   public static void main(String[] args) {
      //创建4个普通窗口
      for(int i=1;i<5;i++){
         ServiceWindow commonWindow = new ServiceWindow();
         commonWindow.setWindowId(i); 
         //用于设置setType，因为默认就是CustomerType.COMMON
      }
      //创建一个快速窗口
      ServiceWindow expressWindow = new ServiceWindow();
      expressWindow.setType(CustomerType.EXPRESS);
      //不用设置setWindowId因为默认为1
      expressWindow.start();
  
      //创建一个VIP窗口
      ServiceWindow vipWindow = new ServiceWindow();
      vipWindow.setType(CustomerType.VIP);
      vipWindow.start();
  
      //动态产生客户（普通：快速：VIP = 6：3：1）
      ScheduledExecutorService pool = Executors.newScheduledThreadPool(3); //参数:池中所保存的线程数。为0时，没有执行Runnable实现类的线程。线程数比Runnable实现类少时，线程切换的为三个Runnable实现类服务。
      pool.scheduleAtFixedRate(
           new Runnable(){
               public void run() {
                  int number = NumberMachine.getInstance().getCommoManager().generateNewManager();
                  System.out.println(number+"号普通客户等待服务！");
               }     
           },
           0,
           Constants.COMMON_CUSTOMER_INTERVAL_TIME,
           TimeUnit.SECONDS);
  
      pool.scheduleAtFixedRate(
           new Runnable(){
               public void run() {
                  int number = NumberMachine.getInstance().getExpressManager().generateNewManager();
                  System.out.println(number+"号快速客户等待服务！");      
               }     
           },
           0,
           Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,
           TimeUnit.SECONDS);
      pool.scheduleAtFixedRate(
           new Runnable(){
               public void run() {
                  int number = NumberMachine.getInstance().getVipManager().generateNewManager();
                  System.out.println(number+"号VIP客户等待服务！");
               }    
           },
           0,
           Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,
           TimeUnit.SECONDS); 
   
   }
}