银行业务调度系统

银行业务调度系统

一，银行业务调度系统题目的来源：这道题依然是张老师的学生去面试时遇到的，看来面试也是很困能，也很考验能力的

二，项目需求

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

     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）对象分析：

        a，有三种对应类型客户：VIP客户，普通客户，快速客户，但客户是由取号机的号码随机产生的，因此一个号码产生器。

        b，又因为每个类型的客户在其对应的窗口办理业务，因此也有三种类型的窗口：VIP窗口，普通窗口，快速窗口

        c，由于客户类型的不同，号码的分类页应该不同，但是号码管理器只能设计一个，因此使用单例设计模式

    2）过程分析：窗口在办理业务的时候，需要向号码器获取服务窗口每次找号码管理器获取当前要被服务的号码。

    3）画图进行分析：客户获取号码，和窗口获取号码的方法都要通过号码管理器获得

四，程序设计（编写代码）

 

//创建一个号码管理器

import java.util.List;

import java.util.ArrayList;

public class NumberManager {

        private int lastNumber;

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

        //定义集合的时候最好用父类来new子类对象，显示比较有能力

        //设置客户取号的方法,由于是多个线程且操作了同个数据，需要加上锁

        public synchronized Integer generateNewManager(){

                   queueNumber.add(lastNumber);

                   return lastNumber++;

         }

         //设置窗口取号的方法

         public synchronized Integer fetchServiceNumber(){

                   Integer number = null;

                   if(queueNumber.size()>0){

                           number = queueNumber.remove(0);

                   }

         return number;

         }

}

//创建号码机器，返回号码管理器

public class NumberMachine {

      

         //创建三个号码管理器，并具有get方法

         private NumberManager commmonMannger = new NumberManager();

         private NumberManager expressManager = new NumberManager();

         private NumberManager vipManager = new NumberManager();

   

         public NumberManager getCommonManager(){

                return commmonMannger;

         }

         public NumberManager getExpressManager(){

               return expressManager;

         }

         public NumberManager getVipManager(){

         return vipManager;

          }

          //创建单例设计模式

         private NumberMachine(){}

         public static NumberMachine getInstance(){

         return instance;

         }

         private static NumberMachine instance = new NumberMachine();

}

//创建服务窗口的类

import java.util.Random;

import java.util.concurrent.Executors;

public class ServiceWindow {

        private CustonerType type = CustonerType.COMMON;

        public void setType(CustonerType type) {

               this.type = type;

        }

        private int windowId = 1;

        public void setWindowId(int windowId) {

              this.windowId = windowId;

        }

        //定义较好的方法

         public void start(){

         //JDK1.5新线程的方法

          Executors.newSingleThreadExecutor().execute(new Runnable(){

                 public void run(){

                        while(true){

                         //由于switch比if else较好，因此选用switch判断客户类型

                         //****switch的数据类型只能是整数即int,枚举也可以

                       switch(type){

                               case COMMON:

                                    commonService();

                              break;

                              case EXPRESS:

                              break;

                              case VIP:

                              break;

                       }                 

                 }     

             }          

        });

     }

    private void commonService() {

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

             System.out.println(windowName+"正在获取任务");

             Integer number = NumberMachine.getInstance().getCommonManager().fetchServiceNumber();

             if(number!=null){

                      long beginTime = System.currentTimeMillis();

                       int maxRand = Constants.MAX_SERVICE_TIME –Constants.MIN_SERVICE_TIME;

                       long service = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME ;

                        //休息的随机时间为1--9000 + 1000为1000--10000

                       try {

                               Thread.sleep(service);

                       }

                      catch (InterruptedException e) {

                              e.printStackTrace();

                      }

                      long eclapsedTime = System.currentTimeMillis()-beginTime;

                      System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+eclapsedTime/1000);

           }

          else{

                      System.out.println(windowName+"没有取到任务，先休息1秒");

                      try {

                               Thread.sleep(1000);

                     }

                     catch (InterruptedException e) {

                               e.printStackTrace();

                     }

               }

          }

          private void expressService() {

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

                    System.out.println(windowName+"正在获取任务");

                    Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();

                    if(number!=null){

                    long beginTime = System.currentTimeMillis();

                    try {

                              Thread.sleep(Constants.MIN_SERVICE_TIME);

                    }

                   catch (InterruptedException e) {

                   e.printStackTrace();

                   }

                  long eclapsedTime = System.currentTimeMillis()-beginTime;

                 System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+eclapsedTime/1000);

                  }else{

                         System.out.println(windowName+"没有取到任务，先休息1秒");

                         commonService();

                         try {

                                   Thread.sleep(1000);

                         } catch (InterruptedException e) {

                                   e.printStackTrace();

                        }

                  }

         }

         private void vipService() {

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

               System.out.println(windowName+"正在获取任务");

                Integer number = NumberMachine.getInstance().getVipManager().fetchServiceNumber();

                if(number!=null){

                       long beginTime = System.currentTimeMillis();

                       int maxRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;

                       long service = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME ;

                          //休息的随机时间为1--9000 + 1000为1000--10000

                       try {

                                   Thread.sleep(service);

                       } catch (InterruptedException e) {

                                   e.printStackTrace();

                       }

                       long eclapsedTime = System.currentTimeMillis()-beginTime;

                      System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+eclapsedTime/1000); 

                      }else{

                                  System.out.println(windowName+"没有取到任务!");

                                  commonService();

                                  try {

                                           Thread.sleep(1000);

                                  } catch (InterruptedException e) {

                                           e.printStackTrace();

                                  }

                        }

              }

}

//由于客户的类型是固定的，只有三种，因此定义一个枚举

public enum CustonerType {

          COMMON,EXPRESS,VIP;

          public String toSring(){

                 switch(this){

                      case COMMON:

                          return "普通";

                     case EXPRESS:

                          return "快速";

                     case VIP:

                         return name();

                  }

                 return null

           }

}

 

//定义时间常量的类

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;

 

}

//建立主函数

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

public class MainClass {

            public static void main(String[] args) {

                    ServiceWindow window = null;

                    //建立普通窗口

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

                           ServiceWindow commonWindow = new ServiceWindow(); commonWindow.setWindowId(i); 

                           commonWindow.start();

             }

             //建立快速窗口

             ServiceWindow expressWindow = new ServiceWindow();expressWindow.setType(CustonerType.EXPRESS);

             expressWindow.start();

      

             //建立VIP窗口

             ServiceWindow vipWindow = new ServiceWindow();vipWindow.setType(CustonerType.VIP);

             vipWindow.start();

      

       //模拟客户

       //普通客户拿号

              Executors.newScheduledThreadPool(1).scheduleAtFixedRate(

                     new Runnable(){

                         public void run(){

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

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

                         }

                     },

                     0,

                     Constants.COMMON_CUSTOMER_INTERVAL_TIME,

                     TimeUnit.SECONDS);

             

              //快速客户拿号

              Executors.newScheduledThreadPool(1).scheduleAtFixedRate(

                     new Runnable(){

                         public void run(){

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

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

                         }

                     },

                     0,

                     Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,

                     TimeUnit.SECONDS);

             

              //VIP客户拿号

              Executors.newScheduledThreadPool(1).scheduleAtFixedRate(

                     new Runnable(){

                         public void run(){

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

                            System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");

                         }

                     },

                     0,

                      Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,

                     TimeUnit.SECONDS);

      

    }

 

}

 

总结：银行调度管理系统，运用了面向对象的思想设计程序，在解决一道很复杂的问题的时候，运用面向对象的思想就很好理解了。本题中具体体现多线程的应用，深入运用了多线程的锁，和等待睡眠机制。

     还要用于接收新事物，多了解了解JDK1.5的新特性，把它运用到现在的学习中，逐步进步。