java 银行模拟叫号系统 黑马程序员学习笔记（9）

总结：

银行业务调度系统的项目需求：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客户，普通客户，快速客户 ，随机生成各种类型的客户.各类型的客户去对应的窗口进行取票。（如果没有快速窗口的客户等待办理业务，则快速窗口可为普通窗口的客户办理相关义务，vip窗口亦然！）

2.号码管理器用来分发不同窗口客户的号码，（总共需要三个不同的号码生成器，来生成对应窗口的号码序列）

Eg：首先，经常在银行办理业务的人更有利于理解本系统，例如，我知道每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。
所以，我想到要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了不同窗口的客户。
由于有三类客户，每类客户的号码编排都是完全独立的，所以，我想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器
对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。(是比较合适的)
2.各类型客户在其对应窗口按顺序依次办理业务 ，号码应该有对应的窗口来叫，也就是对号码管理器要号码（当前服务号码下一位的号码）

总的号码管理器代码

package com.itsofttone.interview.bank;
 
/*
 *总的号码管理器
 */
publicclass NumberMachine {
 
   //定义三个取号器
   private NumberManagercommonManager=new NumberManager();
   private NumberManagerexpressManager=new NumberManager();
   private NumberManagerVipsManager=new NumberManager();
   
   
   public NumberManager getCommonManager() {
       returncommonManager;
    }
   public NumberManager getExpressManager() {
       returnexpressManager;
    }
   public NumberManager getVipsManager() {
       returnVipsManager;
    }
   
 //对象变单例，构造方法私有化
   private NumberMachine(){}
   publicstatic NumberMachine getInstance(){
       //返回自己的对象
       returninstance;
       
    }
   privatestatic NumberMachineinstance =new NumberMachine();
 
 
}

号码生成器

​ 

package com.itsofttone.interview.bank;

import java.util.ArrayList;
import java.util.List;

public class NumberManager {
    /*
     * 多线程操作实现互斥 synchronized
     * 
     */
    private List<Integer> queneNumber =new ArrayList<Integer>();
    private int lastNumber=1;

    //自动拆箱与装箱
    public synchronized Integer generateNewManager(){
        queneNumber.add(lastNumber);
        return lastNumber++;
    }
    //取号码
    public synchronized Integer fetchServiceNumber() {
        //队列先进先出  如果队列里面没有值，则取不出来东西，出现

        if(queneNumber.size()>0){
        return queneNumber.remove(0);
        }
        else{
        return 0;
        }

    }

}

客户的类型定义

package com.itsofttone.interview.bank;
 
publicenum CustmerType {
   COMMEN,EXPRESS,VIP;
   //复写toString方法
   public String toString(){
       switch (this) {
       caseCOMMEN:
           return"普通" ;
       caseEXPRESS:
           return"快速" ;
       caseVIP:
           return"vip";
        }
       returnnull;
    }
 
}
随机生成的时间
package com.itsofttone.interview.bank;
 
publicclass Constants {
   //服务耗费的时间段1-10
   publicstaticintMAX_SERVICE_TIME=10000;
   publicstaticintMIN_SERVICE_TIME=1000;
   //普通客户间隔时间
   publicstaticintCOMMON_CUSTOMER_INTERVAL_TIME=1;
 
}

服务窗口代码

package com.itsofttone.interview.bank;

import java.util.Random;
import java.util.concurrent.Executors;

public class ServiceWindow {
    //枚举类型
    private CustmerType type =CustmerType.COMMEN;
    private int windowId=1;
    //不停的叫号，使用线程
    public void start(){
        //使用jdk1.5的新知识.线程池/线程池找空闲线程。jdk1.5详细学习
        Executors.newSingleThreadExecutor().execute( new Runnable(){

            public void run(){
                //不停的取号
                while (true) {
                    switch(type){

                    case COMMEN:
                        //抽取方法
                        commenService();
                        break;
                       case EXPRESS:
                        expressService();
                         break;
                       case VIP:
                        vipService();
                         break;
                    }
                }
            }


        });
    }
    //可以灵活的定义参数的类型，所以开始没有定死。

    private void commenService() {
        String windowName="第"+windowId+"号"+type+"窗口";
        //上了线程锁进行阻塞，避免阻塞，输出一句话来填充空白
        Integer number= NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
        System.out.println("正在获取任务");
         if(number!=null){
             //定义耗费的时间(耗费时间=结束时间—开始时间)
             long beginTime=System.currentTimeMillis();
             int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;                         long serverTime=0;
             //服务时间
              serverTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
             try {
                  Thread.sleep(serverTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
             long costTime =System.currentTimeMillis()-beginTime;
             System.out.println(windowName+"为第"+number+"个"+"普通"+"客户服务,耗时"+costTime/1000+"秒");

         }
         else{
             System.out.println(windowName+"没有取到任何任务");
             commenService();
             try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
         }
    }
    //获取快速窗口的代码
    private void expressService() {
        String windowName="第"+windowId+"号"+type+"窗口";
        //上了线程锁进行阻塞，避免阻塞，输出一句话来填充空白
        Integer number= NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
        System.out.println("正在获取任务");
         if(number!=null){
             //定义耗费的时间(耗费时间=结束时间—开始时间)
             long beginTime=System.currentTimeMillis();
              int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;                             
             long serverTime=0;
              //服务时间
              serverTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
             try {
                 //最小时间
                  Thread.sleep(Constants.MIN_SERVICE_TIME);
            } catch (Exception e) {
                e.printStackTrace();
            }
             long costTime =System.currentTimeMillis()-beginTime;

             System.out.println(windowName+"为第"+number+"个"+type+"客户服务,耗时"+costTime/1000+"秒");
         }
         else{
             System.out.println(windowName+"没有取到任何任务,先休息一秒钟");
             //暂停一秒继续喊
         }
    }
    //获取vip窗口的代码
    private void vipService() {
        String windowName="第"+windowId+"号"+type+"窗口";
        //上了线程锁进行阻塞，避免阻塞，输出一句话来填充空白
        Integer number= NumberMachine.getInstance().getVipsManager().fetchServiceNumber();
        System.out.println("正在获取任务");
         if(number!=null){
             //定义耗费的时间(耗费时间=结束时间—开始时间)
             long beginTime=System.currentTimeMillis();
             int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;                         long serverTime=0;
             //服务时间
             serverTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
             try {
                  Thread.sleep(serverTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
             long costTime =System.currentTimeMillis()-beginTime;
             System.out.println(windowName+"为第"+number+"个"+type+"客户服务,耗时"+costTime/1000+"秒");
         }
         else{
             System.out.println(windowName+"没有取到任何任务");
             //调用普通的窗口。服务
             commenService();
         }
    }

    public void setType(CustmerType type) {
        this.type = type;
    }
    public void setWindowId(int windowId) {
        this.windowId = windowId;
    }

}
主函数
package com.itsofttone.interview.bank;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MainClass {

    /**
     * @param args
     */
    public static void main(String[] args) {

       //new 4个窗口对象
        for(int i=1;i<5;i++){
            ServiceWindow commenWindow=new ServiceWindow();
            commenWindow.setWindowId(i);
            commenWindow.start();
        }
        //快速
        ServiceWindow espressWindow=new ServiceWindow();
        espressWindow.setType(CustmerType.EXPRESS);
        espressWindow.start();
        //vip
        ServiceWindow vipWindow=new ServiceWindow();
        vipWindow.setType(CustmerType.VIP);
        vipWindow.start();
        //定时线程 模拟普通客户
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable() {

                    public void run() {
                        //叫号
                        Integer number=NumberMachine.getInstance().getCommonManager().generateNewManager();
                        System.out.println(number+"号普通客户进来，等待服务");

                    }
                }, 
                0, 
                1, 
                TimeUnit.SECONDS);
        //vip客户
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable() {
                    public void run() {
                        //叫号
                        Integer number=NumberMachine.getInstance().getVipsManager().generateNewManager();
                        System.out.println(number+"号vip客户进来，等待服务");

                    }
                }, 
                0, 
                6, 
                TimeUnit.SECONDS);
        //快速客户
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable() {

                    public void run() {
                        //叫号
                        Integer number=NumberMachine.getInstance().getExpressManager().generateNewManager();
                        System.out.println(number+"号快速客户进来，等待服务____________________________________");

                    }
                }, 
                0, 
                3, 
                TimeUnit.SECONDS);
    }


}