银行业务调度系统

银行业务调度系统需求：

模拟实现银行业务调度系统逻辑，具体需求如下：

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

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

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

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

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

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

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

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

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

问题分析：

有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。

有三个不同的客户，客户是与取到的号码相关联的，所以可以定义三个号码产生器，每来一位客户，就会产生一位号码。可以通过使用随机产生不同类型的号码来模拟三种类型的客户随机到来。

 

有三个不同类型的窗口按顺序依次办公需要，需要各个窗口使用相应类型的号码管理其产生的号码，叫取相应的客户前来处理业务。

三、具体类的代码实现：
号码管理器：

1.     package cn.itheima.com;  

2.       

3.     import java.util.ArrayList;  

4.     import java.util.List;  

5.       

6.     import javax.print.attribute.IntegerSyntax;  

7.       

8.     /* 

9.      * 号码的管理机器,有产生号码和取号码两个方法 

10.  * 所以要定义一个变量记录上次取 的号码, 

11.  * 和一个list集合用于存储号码 

12.  *  

13.  */  

14. public class NumberManager {  

15.     private Integer lastNumber=1;  

16.     private List<Integer> queueNumbers = new ArrayList<Integer>();  

17.       

18.     public synchronized Integer generateNewNumber(){  

19.         queueNumbers.add(lastNumber++);  

20.         return lastNumber;  

21.     }  

22.       

23.     public synchronized Integer fetchNumber(){  

24.         //如果集合的长度为0,则说明里面没有元素,如果直接取,会  

25.         //出现角标越界 的异常  

26.         if(queueNumbers.size()>0)  

27.             return queueNumbers.remove(0);  

28.         return null;  

29.     }  

30. }  

package cn.itheima.com;

 

import java.util.ArrayList;

import java.util.List;

 

import javax.print.attribute.IntegerSyntax;

 

/*

 * 号码的管理机器,有产生号码和取号码两个方法

 * 所以要定义一个变量记录上次取 的号码,

 * 和一个list集合用于存储号码

 *

 */

public class NumberManager {

  private Integer lastNumber=1;

  private List<Integer> queueNumbers = new ArrayList<Integer>();

 

  public synchronized Integer generateNewNumber(){

   queueNumbers.add(lastNumber++);

   return lastNumber;

  }

 

  public synchronized Integer fetchNumber(){

   //如果集合的长度为0,则说明里面没有元素,如果直接取,会

   //出现角标越界 的异常

   if(queueNumbers.size()>0)

     return queueNumbers.remove(0);

   return null;

  }

}

号码产生器：

1.     package cn.itheima.com;  

2.       

3.     /* 

4.      * 用来管理产生三种号码的机器,所以要有三种号码机器的成员变量 

5.      * 因为只有一个,所以要设计成单例模式 

6.      */  

7.     public class NumberMachine {  

8.       

9.         //单利  

10.     private NumberMachine(){}  

11.     private static NumberMachine instance = new NumberMachine();  

12.     public static NumberMachine getInstance(){  

13.         return instance;  

14.     }  

15.       

16.     private NumberManager commonManager = new NumberManager();  

17.     private NumberManager expressManager = new NumberManager();  

18.     private NumberManager vipManager = new NumberManager();  

19.     public NumberManager getCommonManager() {  

20.         return commonManager;  

21.     }  

22.     public NumberManager getExpressManager() {  

23.         return expressManager;  

24.     }  

25.     public NumberManager getVipManager() {  

26.         return vipManager;  

27.     }  

28.       

29. }  

package cn.itheima.com;

 

/*

 * 用来管理产生三种号码的机器,所以要有三种号码机器的成员变量

 * 因为只有一个,所以要设计成单例模式

 */

public class NumberMachine {

 

  /单例

  private NumberMachine(){}

  private static NumberMachine instance = new NumberMachine();

  public static NumberMachine getInstance(){

   return instance;

  }

 

  private NumberManager commonManager = new NumberManager();

  private NumberManager expressManager = new NumberManager();

  private NumberManager vipManager = new NumberManager();

  public NumberManager getCommonManager() {

   return commonManager;

  }

  public NumberManager getExpressManager() {

   return expressManager;

  }

  public NumberManager getVipManager() {

   return vipManager;

  }

 

}

服务的窗口：

1.     package cn.itheima.com;  

2.       

3.     import java.util.Random;  

4.     import java.util.concurrent.Executors;  

5.       

6.     public class ServiceWindow {  

7.           

8.         //定义要服务的客户类型,初始化为普通用户  

9.         private CustomerType type = CustomerType.COMM;  

10.     //记录是第几号窗口,从1开始  

11.     private int number = 1;  

12.       

13.     public CustomerType getType() {  

14.         return type;  

15.     }  

16.   

17.     public void setType(CustomerType type) {  

18.         this.type = type;  

19.     }  

20.   

21.     public int getNumber() {  

22.         return number;  

23.     }  

24.   

25.     public void setNumber(int number) {  

26.         this.number = number;  

27.     }  

28.   

29.     //服务窗口开始运行,并监听各个号码产生器  

30.     public void start(){  

31.         //启动线程,根据不同的窗口类型,做不同的服务  

32.         Executors.newSingleThreadExecutor().execute(  

33.                 new Runnable() {  

34.                     public void run() {  

35.                         //因为要时钟监听,所以要利用死循环  

36.                         while(true){  

37.                             switch (type) {  

38.                             case COMM:  

39.                                 commonService();  

40.                                 break;  

41.                             case EXPRESS:  

42.                                 expressService();  

43.                                 break;  

44.                             case VIP:  

45.                                 vipService();  

46.                                 break;  

47.                             default:  

48.                                 break;  

49.                             }  

50.                         }  

51.                     }  

52.                 });  

53.     }  

54.   

55.     protected void vipService() {  

56.         String windowName = "第"+number+"号"+type+"窗口";  

57.         System.out.println(windowName+"开始获取任务");  

58.         //从普通号码管理器中取出号码  

59.         Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();  

60.         //在这里要判断取出的号码是否为空,所以,将方法的返回值声明为Integer  

61.         if(serviceNumber!=null){  

62.             //号码不为空,说明有客户要求服务  

63.             System.out.println(windowName+"开始为第"+serviceNumber+"号客户服务");  

64.             //服务时间,采用睡眠的形式  

65.             int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;  

66.             int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;  

67.               

68.             try {  

69.                 Thread.sleep(serviceTime);  

70.             } catch (InterruptedException e) {  

71.                 e.printStackTrace();  

72.             }  

73.             System.out.println(windowName+"完成为第"+serviceNumber+"号vip客户服务，总共耗时" + serviceTime/1000 + "秒");  

74.         }  

75.         else{  

76.             //号码为空,没有vip客户开始转为为普通用户服务  

77.             System.out.println(windowName+"没有取到vip任务,开始为普通客户服务");  

78.             commonService();  

79.         }  

80.           

81.     }  

82.           

83.       

84.   

85.     protected void expressService() {  

86.         String windowName = "第"+number+"号"+type+"窗口";  

87.         System.out.println(windowName+"开始获取任务");  

88.         //从普通号码管理器中取出号码  

89.         Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();  

90.         //在这里要判断取出的号码是否为空,所以,将方法的返回值声明为Integer  

91.         if(serviceNumber!=null){  

92.             //号码不为空,说明有客户要求服务  

93.             System.out.println(windowName+"开始为第"+serviceNumber+"号客户服务");  

94.             //服务时间,采用睡眠的形式  

95.           

96.             int serviceTime = Constants.MIN_SERVICE_TIME;;  

97.               

98.             try {  

99.                 Thread.sleep(serviceTime);  

100.                 } catch (InterruptedException e) {  

101.                     e.printStackTrace();  

102.                 }  

103.                 System.out.println(windowName+"完成为第"+serviceNumber+"号快速客户服务，总共耗时" + serviceTime/1000 + "秒");  

104.             }  

105.             else{  

106.                 //号码为空,开始转化为为普通客户服务  

107.                 System.out.println(windowName+"没有取到快速任务,开始为普通客户服务");  

108.                 commonService();  

109.             }  

110.               

111.         }  

112.               

113.           

114.       

115.         protected void commonService() {  

116.             String windowName = "第"+number+"号"+type+"窗口";  

117.             System.out.println(windowName+"开始获取任务");  

118.             //从普通号码管理器中取出号码  

119.             Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();  

120.             //在这里要判断取出的号码是否为空,所以,将方法的返回值声明为Integer  

121.             if(serviceNumber!=null){  

122.                 //号码不为空,说明有客户要求服务  

123.                 System.out.println(windowName+"开始为第"+serviceNumber+"号客户服务");  

124.                 //服务时间,采用睡眠的形式  

125.                 int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;  

126.                 int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;  

127.                   

128.                 try {  

129.                     Thread.sleep(serviceTime);  

130.                 } catch (InterruptedException e) {  

131.                     e.printStackTrace();  

132.                 }  

133.                 System.out.println(windowName+"完成为第"+serviceNumber+"号普通客户服务，总共耗时" + serviceTime/1000 + "秒");  

134.             }  

135.             else{  

136.                 //号码为空,普通窗口等待一秒钟  

137.                 System.out.println(windowName+"没有取到普通任务,正在空闲一秒");  

138.                 try {  

139.                     Thread.sleep(1000);  

140.                 } catch (InterruptedException e) {  

141.                     e.printStackTrace();  

142.                 }  

143.             }  

144.               

145.         }  

146.     }  

package cn.itheima.com;

 

import java.util.Random;

import java.util.concurrent.Executors;

 

public class ServiceWindow {

 

  //定义要服务的客户类型,初始化为普通用户

  private CustomerType type = CustomerType.COMM;

  //记录是第几号窗口,从1开始

  private int number = 1;

 

  public CustomerType getType() {

   return type;

  }

 

  public void setType(CustomerType type) {

   this.type = type;

  }

 

  public int getNumber() {

   return number;

  }

 

  public void setNumber(int number) {

   this.number = number;

  }

 

  //服务窗口开始运行,并监听各个号码产生器

  public void start(){

   //启动线程,根据不同的窗口类型,做不同的服务

   Executors.newSingleThreadExecutor().execute(

      new Runnable() {

        public void run() {

         //因为要时钟监听,所以要利用死循环

         while(true){

           switch (type) {

           case COMM:

            commonService();

            break;

           case EXPRESS:

            expressService();

            break;

           case VIP:

            vipService();

            break;

           default:

            break;

           }

         }

        }

       });

  }

 

  protected void vipService() {

   String windowName = "第"+number+"号"+type+"窗口";

   System.out.println(windowName+"开始获取任务");

   //从普通号码管理器中取出号码

   Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();

   //在这里要判断取出的号码是否为空,所以,将方法的返回值声明为Integer

   if(serviceNumber!=null){

     //号码不为空,说明有客户要求服务

     System.out.println(windowName+"开始为第"+serviceNumber+"号客户服务");

     //服务时间,采用睡眠的形式

     int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;

     int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;

    

     try {

      Thread.sleep(serviceTime);

     } catch (InterruptedException e) {

      e.printStackTrace();

     }

     System.out.println(windowName+"完成为第"+serviceNumber+"号vip客户服务，总共耗时" + serviceTime/1000 + "秒");

   }

   else{

     //号码为空,没有vip客户开始转为为普通用户服务

     System.out.println(windowName+"没有取到vip任务,开始为普通客户服务");

     commonService();

   }

  

  }

  

 

 

  protected void expressService() {

   String windowName = "第"+number+"号"+type+"窗口";

   System.out.println(windowName+"开始获取任务");

   //从普通号码管理器中取出号码

   Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();

   //在这里要判断取出的号码是否为空,所以,将方法的返回值声明为Integer

   if(serviceNumber!=null){

     //号码不为空,说明有客户要求服务

     System.out.println(windowName+"开始为第"+serviceNumber+"号客户服务");

     //服务时间,采用睡眠的形式

  

     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+"没有取到快速任务,开始为普通客户服务");

     commonService();

   }

  

  }

  

 

 

  protected void commonService() {

   String windowName = "第"+number+"号"+type+"窗口";

   System.out.println(windowName+"开始获取任务");

   //从普通号码管理器中取出号码

   Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();

   //在这里要判断取出的号码是否为空,所以,将方法的返回值声明为Integer

   if(serviceNumber!=null){

     //号码不为空,说明有客户要求服务

     System.out.println(windowName+"开始为第"+serviceNumber+"号客户服务");

     //服务时间,采用睡眠的形式

     int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;

     int serviceTime = new Random().nextInt(maxRandom)+1 + 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+"没有取到普通任务,正在空闲一秒");

     try {

      Thread.sleep(1000);

     } catch (InterruptedException e) {

      e.printStackTrace();

     }

   }

  

  }

}

客户的类型：定义为枚举类型（普通，快速，vip）

1.     package cn.itheima.com;  

2.       

3.     enum CustomerType {  

4.         COMM,EXPRESS,VIP;  

5.         @Override  

6.         //重写toString（）方法  

7.         public String toString() {  

8.             switch(this){  

9.                 case COMM:  

10.                 return "普通";  

11.             case EXPRESS:  

12.                 return "快速";  

13.             case VIP:  

14.                 return name();  

15.         }  

16.         return null;  

17.     }  

18. }  

package cn.itheima.com;

 

enum CustomerType {

  COMM,EXPRESS,VIP;

  @Override

  //重写toString（）方法

  public String toString() {

   switch(this){

     case COMM:

      return "普通";

     case EXPRESS:

      return "快速";

     case VIP:

      return name();

   }

   return null;

  }

}

常量类：

1.     package cn.itheima.com;  

2.       

3.     public class Constants {  

4.         //最大的服务是时间  

5.         public static int MAX_SERVICE_TIME = 10000; //10秒！  

6.         //客户最小的服务时间  

7.         public static int MIN_SERVICE_TIME = 1000; //1秒！  

8.         //客服来的时间间隔  

9.         public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;  

10. }  

package cn.itheima.com;

 

public class Constants {

  //最大的服务是时间

  public static int MAX_SERVICE_TIME = 10000; //10秒！

  //客户最小的服务时间

  public static int MIN_SERVICE_TIME = 1000; //1秒！

  //客服来的时间间隔

  public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;

}

运行系统的主类

1.     package cn.itheima.com;  

2.       

3.     import java.util.concurrent.Executors;  

4.     import java.util.concurrent.TimeUnit;  

5.       

6.     import javax.jws.soap.SOAPBinding.Use;  

7.       

8.     public class MainClass {  

9.         public static void main(String[] args) {  

10.         //产生4个普通窗口,并开始监听窗口  

11.         for(int i=1;i<5;i++){  

12.             ServiceWindow commWindow = new ServiceWindow();  

13.             commWindow.setNumber(i);  

14.             commWindow.setType(CustomerType.COMM);  

15.             commWindow.start();  

16.         }  

17.         //产生1个快速窗口  

18.         ServiceWindow expressWindow = new ServiceWindow();  

19.         expressWindow.setNumber(5);  

20.         expressWindow.setType(CustomerType.EXPRESS);  

21.         expressWindow.start();  

22.         //产生一个vip窗口  

23.         ServiceWindow vipWindow = new ServiceWindow();  

24.         vipWindow.setNumber(6);  

25.         vipWindow.setType(CustomerType.COMM);  

26.         vipWindow.start();  

27.           

28.         //开启三个定时器,每隔一段时间号码机器产生一个号码  

29.         //普通客户  

30.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  

31.                 new Runnable() {  

32.                     @Override  

33.                     public void run() {  

34.                         Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();  

35.                         System.out.println("第"+serviceNumber+"普通客户正在等待服务");  

36.                     }  

37.                 },   

38.                 0,  

39.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME,   

40.                 TimeUnit.SECONDS  

41.             );  

42.           

43.         //快速客户  

44.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  

45.                 new Runnable() {  

46.                     @Override  

47.                     public void run() {  

48.                         Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();  

49.                         System.out.println("第"+serviceNumber+"快速客户正在等待服务");  

50.                     }  

51.                 },   

52.                 0,  

53.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME*2,   

54.                 TimeUnit.SECONDS  

55.             );  

56.           

57.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  

58.                 new Runnable() {  

59.                     @Override  

60.                     public void run() {  

61.                         Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();  

62.                         System.out.println("第"+serviceNumber+"vip客户正在等待服务");  

63.                     }  

64.                 },   

65.                 0,  

66.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME*6,   

67.                 TimeUnit.SECONDS  

68.             );  

69.     }  

70. }