(18) - 银行业务调度管理系统(7k面试题)

最新推荐文章于 2015-05-06 02:16:32 发布

zzbxsdby

最新推荐文章于 2015-05-06 02:16:32 发布

阅读量700

点赞数

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/zzbxsdby/article/details/12112463

版权

java学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

一道某公司面试题，学习张老师的视频后稍做了点改动，对于一些知识点的应用有一定帮助。

1、系统需求

(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方式展现程序的运行结果。

2、需求分析

实际中，客户办理业务先在取号机器上获取对应服务类型的排队号码，再由银行空闲的业务窗口叫号给对应号码的客户服务。从面向对象的角度出发，分析该系统：

(1)   需要三种窗口：普通窗口，快速窗口，VIP窗口。窗口需有按顺序取号(叫号)和服务的功能，当快速窗口和VIP窗口空闲时刻可处理用作普通窗口处理普通客户的业务。

(2)   有三种客户：普通客户、快速客户、VIP客户，在这里异步随机生成，用户出现的数量比例为：VIP客户：普通客户：快速客户 =1：6：3，即6*vip = 1*普通 = 2*快速。那么假设普通客户1秒一个，vip和快速分别为6秒和2秒。

(3)   号码管理器，就是个号码缓存队列，管理生成号码和取出号码，保证号码的连续性和同步性。

(4)   号码机器，为客户取号和窗口叫号服务。利用号码管理器，产生三类客户的排序号码，三类客户各使用一个号码管理器对象，且在整个系统中取号机器必须保证唯一，这里采用单例模式设计。

3、技术点

(1)   应用枚举类，枚举普通，快速，VIP三种类型。

(2)   单例设计模式设计号码机器对象，保证号码的统一配置。

(3)   应用线程池技术，设计窗口服务。

(4)   定时器线程模拟按一定比率生成测试客户(即不同客户取号)。

(5)   用到JavaBean。

4、类说明

MainClass类：主调用类，创建窗口，不同类型客户开始取号。

ServiceWindow类：窗口类，实现普通，快速，VIP三种类型的窗口的服务功能。

NumberManager类：号码管理，号码队列，依次产生号码和取走号码。

NumberMachine类：为三类用户产生NumberManager对象，每类用户分别使用一个号码队列。该类为单例。

CustomerType类：枚举类，枚举普通，快速，VIP类型。

Tools类，静态工具类，含有时间常量，和产生随机时间。

基本类图：

5、系统基本框架

以下是系统的基本框架图，能够看出其工作流程较简单：

基本流程：模拟某类客户取号------>号码机器为其按顺序生成号码------>加入号码队列------>窗口从队列中取号------>为对应客户服务。

6、示例代码

MainClass类（main入口）

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
/**
 主调用类，负责产生窗口和开启不同类型客户取号
 */
public class MainClass {
public static void main(String[] args) {
        //创建窗口
        createWindow();
       
        //普通客户拿号，利用定时器线程
        getNumber(CustomerType.COMMON, 1);
       
        //快速客户拿号，利用定时器线程
        getNumber(CustomerType.EXPRESS, 2);
       
        //VIP客户拿号，利用
        getNumber(CustomerType.VIP, 6);
}
//创建窗口
public static void createWindow(){
        for(int i=1; i<5; i++)
        {
               //1-4号为普通窗口
               createWindow(CustomerType.COMMON,i);
        }
        //产生1个快速窗口
        createWindow(CustomerType.EXPRESS, 5);
        //产生1个VIP窗口
        createWindow(CustomerType.VIP, 6);
}
//窗口设置
public static ServiceWindow createWindow(finalCustomerType type, int nId){
        ServiceWindow window = new ServiceWindow();
        window.setType(type);
        window.setWindowId(nId);
        window.start();
        return window;
}
//不同客户拿号
public static void getNumber(final CustomerTypetype, int time){
        //定时器线程
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                      new Runnable(){
                             public void run() {
                                    //找机器要服务号码，即为不同客户生成排队号码。
                                    Integernumber  = NumberMachine.getInstance().getManager(type).generateNewManager();
                                    System.out.println("get--------"+number+ "号"+type+"用户等待服务！");
                             }},
                      0, //启动时间
                      Tools.COMMON_CUSTOMER_INTERVAL_TIME*time,//不同客户拿号间隔时间
                      TimeUnit.SECONDS//计时单位：秒
               );
}

ServiceWindow类

import java.util.Random;
import java.util.concurrent.Executors;
 
/**
各类型窗口的服务功能，未划分成子类形式
 */
public class ServiceWindow {
    private CustomerType type = CustomerType.COMMON;//窗口类型
    private int windowId = 1;//窗口序号
    private Integer callNumber = null;//窗口取号
    private String windowName = null;//窗口名
    
    public void setType(CustomerType type) {
        this.type = type;
    }
    public void setWindowId(int windowId) {
        this.windowId = windowId;
       
    }
    //开启窗口的服务线程
    public void start(){
        Executors.newSingleThreadExecutor().execute(newRunnable(){
               public void run(){
                      while(true){
                             switch(type)
                             {
                                    case COMMON:
                                           commonService();//普通窗口的服务
                                           break;
                                    case EXPRESS:
                                           expressService();//快速的
                                           break;
                                    case VIP:
                                           vipService();//vip的
                                           break;
                             }
                      }
               }
        });
    }
    //窗口取号
    private void fetchNumber(CustomerTypeclientType){
        callNumber =  NumberMachine.getInstance().getManager(clientType).fetchServerNumber();
        System.out.println("........................................"+windowName+"正在获取任务！");
    }

    //普通客户的服务
    private void commonService(){
        windowName = "第"+windowId+"号("+ type+")窗口";
       
        //根据客户类型取号
        fetchNumber(CustomerType.COMMON);
       
        if(callNumber != null){
               System.out.println("runing-----"+windowName+"为"+callNumber+"号普通客户服务");
               //为普通客户服务所耗时间
               long time = Tools.delayTime();    
               System.out.println("over-------"+windowName+"为"+callNumber+"号普通客户完成服务，耗时"+time/1000+"秒");
      
        }else{
               System.out.println("........................................"+windowName+"没有取到服务任务，先休息1秒钟!");
               Tools.sleepTime(1000);
        }
    }
    //快速客户的服务
    private void expressService(){
        windowName = "第"+windowId+"号("+ type+")窗口";
 
        //根据客户类型取号
        fetchNumber(CustomerType.EXPRESS);
       
        if(callNumber != null){
               System.out.println("runing-----"+windowName+"为"+callNumber+"号"+type+"客户服务");
              
               //最小的服务时间
               long time =Tools.sleepTime(Tools.MIN_SERVICE_TIME);
               System.out.println("over-------"+windowName+"为"+callNumber+"号"+type+"客户完成服务，耗时"+time/1000+"秒");
       
        }else{
               commonService();
        }
    }

    //vip客户的服务
    private void vipService(){
        windowName = "第"+windowId+"号("+ type+")窗口";
       
        //根据客户类型取号
        fetchNumber(CustomerType.VIP);
       
        if(callNumber != null){
               System.out.println("runing-----"+windowName+"为"+callNumber+"号"+type+"客户服务");
              
               //为vip客户服务所耗时间
               long time  = Tools.delayTime();
 
               System.out.println("over-------"+windowName+"为"+callNumber+"号"+type+"客户完成服务，耗时"+time/1000+"秒");
        }else{
               commonService();
        }
    }
 }

NumberManager类

import java.util.ArrayList;
import java.util.List;
/*
号码队列管理，需号码在多线程下同步
 */
public classNumberManager {
    private int lastNumber = 0;
    private List<Integer> queueNumber = new ArrayList<Integer>();
    //生成号码，压入队列，需互斥
    public synchronized  Integer generateNewManager(){
        queueNumber.add(++lastNumber);
        return lastNumber;
    }
    //取号
    public synchronized IntegerfetchServerNumber(){
        if(queueNumber.size() > 0){
               return(Integer)queueNumber.remove(0);
        }
        return null;
    }
}

NumberMachine类

/**
       单例模式，产生号码队列管理实例，各类型用户有自己的号码队列
 */
public class NumberMachine {
    private NumberManager commonManager = new NumberManager();
    private NumberManager expressManager = new NumberManager();
    private NumberManager vipManager = new NumberManager();
    //单例模式
    private NumberMachine(){}//私有构造函数
    private static NumberMachine instance = newNumberMachine();
    public static NumberMachine getInstance(){
        return instance;
    }
    //根据参数返回号码管理器对象
    public NumberManager getManager(CustomerTypetype){
        switch(type){
        case COMMON:
               return commonManager;
        case EXPRESS:
               return expressManager;
        case VIP:
               return vipManager;
        }
        return null;
    }
}

Tools类

import java.util.Random;
/**
 工具类，包含时间的最大最小值，以及产生随机时间的功能
 */
public class Tools {
    public static int MAX_SERVICE_TIME = 10000;//10秒
    public static int MIN_SERVICE_TIME = 1000;//1秒
    //普通客户间隔时间，1秒产生一个普通客户
    public static int COMMON_CUSTOMER_INTERVAL_TIME= 1;
    //获得一个最大和最小服务时间之间的随机服务时间耗时
    public static long delayTime(){
        int maxRand = Tools.MAX_SERVICE_TIME -Tools.MIN_SERVICE_TIME;
        long serviceTime = newRandom().nextInt(maxRand)+1+Tools.MIN_SERVICE_TIME;
 
        return sleepTime(serviceTime);//延迟
     }
    //延迟
    public static long sleepTime(long serviceTime){
        long time = System.currentTimeMillis();
        try {
               Thread.sleep(serviceTime);
        } catch (InterruptedException e) {
               e.printStackTrace();
        }
        //返回所耗时间
        return System.currentTimeMillis()-time;
    }
}

CustomerType类

/**
 枚举类，枚举普通，快速，VIP的类型
 */
public enumCustomerType {
    COMMON,EXPRESS,VIP;
    
    public String toString(){
        switch(this){
        case COMMON:
               return "普通";
        case EXPRESS:
               return "快速";
        case VIP:
               return "VIP";
        }
        return null;
    }
}

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------