黑马程序员_银行业务调度学习总结

最新推荐文章于 2014-07-31 20:10:03 发布

liliangyzq

最新推荐文章于 2014-07-31 20:10:03 发布

阅读量522

点赞数

文章标签：黑马程序员对象

本文链接：https://blog.csdn.net/liliangyzq/article/details/12529121

版权

------- android培训、java培训、期待与您交流！ ----------

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

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

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

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

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

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

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

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

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

我们已经学过交通灯的问题了，这个题跟那个差不多，接下来我们就分析一下这个题：

1. 有三种类型的客户：VIP客户、普通客户、快速客户，异步随机生成各种类型的客户，各种类型的客户在对应的窗口按顺序依次办理业务。每一个客户其实就是由银行的一个取号机产生号码的方式来表示的，所以要有一个号码管理器，让其不断地产生号码，也就等于随机生成客户；

由于有三种类型的客户，每类客户的号码编排都是独立的，所以要有三个号码管理器，各自管理一类客户的排队号码，这三个号码管理器统一由一个号码机进行管理，这个号码机在整个系统中始终只有一个，所以要设计成单例。

2. 各类型的客户等待窗口叫号，按顺序依次在对应的窗口办理业务。窗口怎么知道该叫哪一个号码呢？它一定是问相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

面向对象的分析设计

1. 题目所涉及到的类有哪些？

NumberManager类：产生号码

NumberMachine类：号码机，管理三类客户的号码管理器

CustomerType类：定义三种类型的客户，所以用枚举

ServiceWindow类:服务窗口

Constants类：时间常量

MainClass类：启动调度系统

2. 每个类包含哪些成员？

NumberManager类：

定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合；

定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作相同的数据，所以要同步。

NumberMachine类：

定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定义三个对应的方法来返回这三个NumberManager对象。
将NumberMachine类设计成单例。
CustomerType类：

系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户。
重写toString方法，返回类型的中文名称。
ServiceWindow类:

定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。
    定义三个方法分别对三种客户进行服务
    Constants类：
              定义三个常量，MAX_SERVICE_TIME办理业务所需时间最大值
                                      MIN_SERVICE_TIME办理业务所需时间最小值
                                     COMMON_CUSTOMER_INTERVAL_TIME 产生客户的时间
MainClass类：

用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。
接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。
3. 各类之间的关系，如图：

分析完之后我们就可以写代码了：

NumberManager类：

/**
 *   客户通过取号机取号，取号机调用号码生成器的generateNumber()方法取号，号码生成器把客户取的号存入对应客户类型的号码排队队列。
 *   对应的窗口调用取号机的fetchServiceNumber()从对应的号码排队队列中取出第一个号码，进行叫号服务。
 */
import java.util.ArrayList;
import java.util.List;

public class NumberManager {
     private int lastNumber = 1;  
         //定义集合，将号码存储到集合中
        private List<Integer> queueNumbers = new ArrayList<Integer>();  
        public synchronized Integer generateNewNumber(){
            queueNumbers.add(++lastNumber);
            return lastNumber;
        }
        //取出将要被服务的号码
        public synchronized Integer fetchNumber(){
            if(queueNumbers.size()>0){
                return (Integer)queueNumbers.remove(0);
            }else{
                return null;
            }
        }
}

NumberMachine类：

/*
 *     定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定 义三个对应的方法来返回这三个NumberManager对象。
 *    将NumberMachine类设计成单例。
 */
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;
    }
}

CustomerType类：

/*
 *         三种类型的客户，并重写toString方法
 */
public enum CustomerType {
    COMMON,EXPRESS,VIP;
    public String toString(){
        String name = null;
        switch(this){
        case COMMON:
            name = "普通";
            break;
        case EXPRESS:
            name = "快速";
            break;
        case VIP:
            name = name();
            break;
        }
        return name;
    }
}

ServiceWindow类:

/**
 * 服务窗分为：普通窗口、快速窗口、vip窗口
 * 普通窗口：普通窗口开启后循环从普通客户排队队列中取出第一个客户进行服务
 * 快速窗口：快速窗口开启后循环从快速客户排队队列中取出第一个客户进行服务，若无快速客户，从普通客户排队队列中取出第一个普通客户进行服务
 * vip窗口：vip窗口开启后循环从vip客户排队队列中取出第一个客户进行服务，若无vip客户，从普通客户排队队列中取出第一个普通客户进行服务
 */
import java.util.Random;  
import java.util.concurrent.Executors;

public class ServiceWindow {
    private CustomerType type = CustomerType.COMMON;  
    private int number = 1;  
  
    public CustomerType getType() {
        return type;
    }

    public void setType(CustomerType type) {
        this.type = type;
    }
    
    public void setNumber(int number){
        this.number = number;
    }
    //开始服务  
    public void start() {  
        Executors.newSingleThreadExecutor().execute(new Runnable() {  
            public void run() {  
                while (true) {  
                    switch (type) {  
                    case COMMON:  
                        commonService();  
                        break;  
                    case EXPRESS:  
                        expressService();  
                        break;  
                    case VIP:  
                        vipService();  
                        break;  
                    }  
  
                }  
            }  
        });  
    }  
    //普通窗口开始叫普通客户  
    private void commonService() {  
        String windowName = "第" + number + "号" + type + "窗口";  
        System.out.println(windowName + "正在获取任务");  
        Integer number = NumberMachine.getInstance().getCommonManager()  
                .fetchNumber();  
        if (number != null) {  
            long beginTime = System.currentTimeMillis();  
            int maxRand = Constants.MAX_SERVICE_TIME  
                    - Constants.MIN_SERVICE_TIME;  
            long serveTime = new Random().nextInt(maxRand) + 1  
                    + Constants.MIN_SERVICE_TIME;  
            System.out.println(windowName + "正在为第" + number + "个" + type  
                    + "客户服务");  
            try {  
                Thread.sleep(serveTime);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
  
            long endTime = System.currentTimeMillis();  
            System.out.println(windowName + "为第" + number + "个" + type  
                    + "客户完成服务,耗时" + (endTime - beginTime) / 1000 + "s");  
        } else {  
            System.out.println(windowName + "没有取到任务，先休息1秒钟！");  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
    //快速窗口开始叫快速客户的号，若无快速客户，叫普通客户。  
    private void expressService() {  
        String windowName = "第" + number + "号快速窗口";  
        System.out.println(windowName + "正在获取任务");  
        Integer number = NumberMachine.getInstance().getExpressManager()  
                .fetchNumber();  
        if (number != null) {  
            long beginTime = System.currentTimeMillis();  
            long serveTime = Constants.MIN_SERVICE_TIME;  
            System.out.println(windowName + "正在为第" + number + "个" + type  
                    + "客户服务");  
            try {  
                Thread.sleep(serveTime);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
  
            long endTime = System.currentTimeMillis();  
            System.out.println(windowName + "为第" + number + "个" + type  
                    + "客户完成服务,耗时" + (endTime - beginTime) / 1000 + "s");  
        } else {  
            commonService();  
        }  
    }  
    //vip窗口开始叫vip客户的号，若无vip客户，叫普通客户。  
    private void vipService() {  
        String windowName = "第" + number + "号VIP窗口";  
        System.out.println(windowName + "正在获取任务");  
        Integer number = NumberMachine.getInstance().getVipManager()  
                .fetchNumber();  
        if (number != null) {  
            long beginTime = System.currentTimeMillis();  
            int maxRand = Constants.MAX_SERVICE_TIME  
                    - Constants.MIN_SERVICE_TIME;  
            long serveTime = new Random().nextInt(maxRand) + 1  
                    + Constants.MIN_SERVICE_TIME;  
            System.out.println(windowName + "正在为第" + number + "个" + type  
                    + "客户服务");  
            try {  
                Thread.sleep(serveTime);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
  
            long endTime = System.currentTimeMillis();  
            System.out.println(windowName + "为第" + number + "个" + type  
                    + "客户完成服务,耗时" + (endTime - beginTime) / 1000 + "s");  
        } else {  
            System.out.println(windowName + "没有取到任务，先休息1秒钟！");  
            commonService();  
        }  
    } 
}

Constants类：

/*
 *         定义三个常量：MAX_SERVICE_TIME   MIN_SERVICE_TIME   OMMON_CUSTOMER_INTERVAL_TIME = 1
 */

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; 
}

MainClass类：

/**
 * 开启6个服务窗口(6个服务线程)，按各自窗口的服务规则，开始循环检索客户排队队列，开始服务。
 * 启动三个定时器，按各自的频率生成模拟客户，进行取号排队。以至系统自动运作
 */
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MainClass {
    public static void main(String[] args) {  
        //产生4个普通窗口
                for(int i=1;i<5;i++){
                    ServiceWindow window =  new ServiceWindow();
                    window.setNumber(i);
                    window.start();
                }
            
                //产生1个快速窗口
                ServiceWindow expressWindow =  new ServiceWindow();
                expressWindow.setNumber(5);
                expressWindow.setType(CustomerType.EXPRESS);
                expressWindow.start();
                
                //产生1个VIP窗口        
                ServiceWindow vipWindow =  new ServiceWindow();
                vipWindow.setNumber(6);
                vipWindow.setType(CustomerType.VIP);
                vipWindow.start();        
                
                //普通客户拿号
                Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                        new Runnable(){
                            public void run(){
                                Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();
                                /**
                                 * 采用logger方式，无法看到直观的运行效果，因为logger.log方法内部并不是直接把内容打印出出来，
                                 * 而是交给内部的一个线程去处理，所以，打印出来的结果在时间顺序上看起来很混乱。
                                 */
                                //logger.info("第" + serviceNumber + "号普通客户正在等待服务！");
                                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().generateNewNumber();
                                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().generateNewNumber();
                                System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");
                            }
                        },
                        0,
                        Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6, 
                        TimeUnit.SECONDS);
            }
}