用java模拟银行业务调度系统

来源：互联网发布：js格式化时间戳format 编辑：程序博客网时间：2024/06/05 12:01

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

1.银行内有六个业务调度窗口，1-4号为普通窗口，5号为快速窗口，6号为vip窗口

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

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

vip客户：普通客户：快速客户=1：6:3

4.客户办理业务所需的时间有最大值和最小值，该范围内随机设定每个vip客户以及普通客户办理业务所需的时间，快速客户办理业务所需的时间为最小值

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

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

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

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

分析：

首先我们先想象一下我们到银行办理业务的流程，客户到银行的排号机上先去排号打印出自己的号码，然后等待窗口的叫号，叫到底号码以后，则相应号码的客户到相应的窗口办理自己的业务。在这个系统中涉及到了三个对象，窗口的类型、窗口类、客户领号的机器，由此我们设计出了CustomerType、NumberManager、NumberMachine、ServiceWindow四个类，CustomerType代表客户的类型，同时也对应了银行的窗口类型，NumberManager用于产生客户排的号码，这个类为客户通过排号，还为窗口取出号码叫号，同时取号和产生号码的方法应该采用同步锁，因为操作了共同的数据，NumberMachine用于产生不同类型业务对象的实例，相当于排号机，ServiceWindow对应于窗口的功能，叫号并处理业务。

项目源码如下：

CustomerType类

package com.wj.interview.bank;

public enum CustomerType {
   COMMON,EXPRESS,VIP;

   @Override
   public String toString() {
       switch(this) {
       case COMMON:
           return "普通";
       case EXPRESS:
           return "快速";
       case VIP:
           return "VIP";
       }
       return null;
   }
}

NumberManager类

package com.wj.interview.bank;

import java.util.ArrayList;
import java.util.List;
/**
*
* @author wJing
* 号码产生器
*/
public class NumberManager {
   private int lastNumber = 1;
   private List<Integer> queueNumber = new ArrayList<Integer>();
   //这两个方法提供给不同的操作者，为了互斥，所以必须采用异步
   public synchronized Integer generateNewNumber() {
       queueNumber.add(lastNumber);
       return lastNumber++;
   }
   public synchronized Integer fetchServiceNumber() {
       Integer number = null;
       if(queueNumber.size() > 0) {
           number = queueNumber.remove(0);
       }
       return number;
   }
}
NumberMachine类
package com.wj.interview.bank;
/**
*
* @author wJing
* 排号机，产生普通、快速、vip业务的实例，单例实现
*/
public class NumberMachine {
   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;
   }
   private NumberMachine() {

   }
   //单例对象
   public static NumberMachine newInstance() {
       return instance;
   }
   private static NumberMachine instance = new NumberMachine();
}
Constants类
package com.wj.interview.bank;
/**
*
* @author wJing
* 常量，程序中要使用的常量，可以方便系统的配置
*/
public class Constants {
   public static int MAX_SERVER_TIME = 10000;
   public static int MIN_SERVER_TIME = 1000;
   public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;
}
ServiceWindow类

package com.wj.interview.bank;

import java.util.Random;
import java.util.concurrent.Executors;
/**
*
* @author wJing
* 窗口类，办理业务的窗口
*
* 可以采用继承的方式，把ServiceWindow衍生出2个子类，子类继承父类commonService（）方法，并且
* 将commonService（）中的代码抽取为方法，子类只需要新建出方法新的业务方法就行了，这样做可以大大减少
* 重复代码，提高代码的复用率，更体现了面向对象的思想
*/
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() {

                   @Override
                   public void run() {
                       while(true) {

                           switch(type) {
                           case COMMON:
                               commonService();   //普通窗口
                               break;
                           case EXPRESS:
                               expressService();   //快速窗口
                               break;
                           case VIP:
                               vipService();       //vip窗口
                               break;
                           }
                       }
                   }

               });
   }
   /**
   * 普通窗口服务方法
   */
   private void commonService() {
       String windowName = "第" + windowId + "号" + type + "窗口";
       //从排号机里面取出一个号码
       Integer number = NumberMachine.newInstance()
                       .getCommonManager().fetchServiceNumber();

       System.out.println(windowId + "号窗口正在获取任务");
       //如果取到了号码
       if(number != null) {
           System.out.println(windowName + "为第" + number + "个" + "普通" + "客户服务");
           long startTime = System.currentTimeMillis();
           int maxRand = Constants.MAX_SERVER_TIME - Constants.MIN_SERVER_TIME;
           long serverTime = new Random().nextInt(maxRand) + Constants.MIN_SERVER_TIME;
           try {
               //办理业务的随机时间，睡眠serverTime
               Thread.sleep(serverTime);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           //花费的时间
           long costTime = System.currentTimeMillis() - startTime;
           System.out.println(windowName + "为第" + number + "个" + "普通" + "客户完成任务，耗时" + costTime / 1000 + "秒");
       } else {
           System.out.println(windowId + "号窗口没有取到任务,先休息一秒钟");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
   /**
   * 快速窗口服务方法，当前窗口无人是要服务普通客户
   */
   private void expressService() {
       String windowName = "第" + windowId + "号" + type + "窗口";
       //从排号机里面取出一个号码
       Integer number = NumberMachine.newInstance()
                       .getExpressManager().fetchServiceNumber();

       System.out.println(windowId + "号窗口正在获取任务");
       if(number != null) {
           System.out.println(windowName + "为第" + number + "个" + type + "客户服务");
           long startTime = System.currentTimeMillis();
           try {
               Thread.sleep(Constants.MIN_SERVER_TIME);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           long costTime = System.currentTimeMillis() - startTime;
           System.out.println(windowName + "为第" + number + "个" + type + "客户完成任务，耗时" + costTime / 1000 + "秒");
       } else {
           System.out.println(windowId + "号窗口没有取到任务!");
           commonService();
       }
   }
   /**
   * 普通窗口服务方法，当前窗口无人是要服务普通客户
   */
   private void vipService() {
       String windowName = "第" + windowId + "号" + type + "窗口";
       //从排号机里面取出一个号码
       Integer number = NumberMachine.newInstance()
                       .getVipManager().fetchServiceNumber();

       System.out.println(windowId + "号窗口正在获取任务");
       //如果取到了号码
       if(number != null) {
           System.out.println(windowName + "为第" + number + "个" + type + "客户服务");
           long startTime = System.currentTimeMillis();
           int maxRand = Constants.MAX_SERVER_TIME - Constants.MIN_SERVER_TIME;
           long serverTime = new Random().nextInt(maxRand) + Constants.MIN_SERVER_TIME;
           try {
               Thread.sleep(serverTime);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           long costTime = System.currentTimeMillis() - startTime;
           System.out.println(windowName + "为第" + number + "个" + type + "客户完成任务，耗时" + costTime / 1000 + "秒");
       } else {
           System.out.println(windowId + "号窗口没有取到任务!");
           commonService();
       }
   }
}
MainClass类

package com.wj.interview.bank;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
*
* @author wJing
* 2014-3-14 17:55:57
* 银行业务调度系统
*/
public class MainClass {

   public static void main(String[] args) {
       //生成普通业务的5个窗口
       for(int i = 1; i < 5; i++) {
           ServiceWindow commonWindow = new ServiceWindow();
           //设置窗口号
           commonWindow.setWindowId(i);
           //启动开始业务办理
           commonWindow.start();
       }
       //生成快速窗口
       ServiceWindow expressWindow = new ServiceWindow();
       //设置窗口类型为快速窗口
       expressWindow.setType(CustomerType.EXPRESS);
       //设置窗口号为5号
       expressWindow.setWindowId(5);
       expressWindow.start();
       //生成vip窗口
       ServiceWindow vipWindow = new ServiceWindow();
       //设置窗口类型为vip窗口
       vipWindow.setType(CustomerType.VIP);
       //设置窗口号为6号
       vipWindow.setWindowId(6);
       vipWindow.start();

       //定时器，每隔1秒取一个叫一个普通用户,为满足vip客户：普通客户：快速客户=1：6:3
       Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
               new Runnable() {

                   @Override
                   public void run() {
                       //通过叫号机生成一个用户
                       Integer number = NumberMachine.newInstance().getCommonManager().generateNewNumber();
                       System.out.println(number + "号普通客户等待服务");
                   }

               },
               0,
               Constants.COMMON_CUSTOMER_INTERVAL_TIME,
               TimeUnit.SECONDS);
       //定时器，每隔2秒取一个叫一个普通用户,为满足vip客户：普通客户：快速客户=1：6:3
       Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
               new Runnable() {

                   @Override
                   public void run() {
                       //通过叫号机生成一个用户
                       Integer number = NumberMachine.newInstance().getExpressManager().generateNewNumber();
                       System.out.println(number + "号普通快速等待服务");
                   }

               },
               0,
               Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,
               TimeUnit.SECONDS);
       //定时器，每隔6秒取一个叫一个普通用户,为满足vip客户：普通客户：快速客户=1：6:3
       Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
               new Runnable() {

                   @Override
                   public void run() {
                       //通过叫号机生成一个用户
                       Integer number = NumberMachine.newInstance().getVipManager().generateNewNumber();
                       System.out.println(number + "号vip客户等待服务");
                   }

               },
               0,
               Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,
               TimeUnit.SECONDS);
       }

}

0 0