银行业务调度系统

1,项目的具体需求

银行业务调度系统

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

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

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

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

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

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

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

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

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

不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

     看完张老师的这个银行业务调度系统,要想把Java学深,多线程这块是大头,当然所有的技术都建立你有这良好的面向对象设计的感觉,在项目中,只有抓住关键的名词,和它所具有的数据和方法,良好的面向对象的感觉是做一个项目的起点.

2,面向对象具体分析加代码实现

由于本人在之前是在类似的银行的地方工作过,对这个叫号系统运作的有一定的认识,一般的步骤是

(1)顾客进入大厅,在叫号机器上去号码(一般大厅只有一个叫号器),不同业务的顾客叫的号码是不同的,这里根据需求,有3种类型的号码,在这个步骤中,涉及到2个名词叫号机器和顾客

(2)这个时候,窗口的工作人员开始叫号,对应的顾客来办理业务,这里窗口工作人员也是个名词

通过以上2个步骤,可以发现叫号器是在打印号码出来,这个打印的动作是在叫号机器上面的,根据面向对象设计的原理,有一个叫号机器,它来产生3个号码管理器,而叫号器一般在大厅只有1台,那么设计叫号器这个类的时候,要将它设计成单例模式.

同时窗口人员要通过叫号机器来获取当前要被服务的号码

NumberManager类:一个是上一个被服务号码的变量,还有是所有等待的号码的集合,定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步synchronized

NumberMachine类:单例模式,3个对象,VIP,快速和普通

CustomerType枚举类:存放客户的类型,已经客户类型的英文对应的中文,复写toString()方法

ServiceWindow类:3个方法,服务VIP,快速和普通,在同一线程中操作,这里又得用到JDK1.5出现的新线程的技术

MainClass类:运行类,for循环来模拟出3类客户,同时用新线程的定时启动线程,来设置客户进入的时间

3,代码的实现

package cn.wjd.bank;

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

public class NumberManager {
    //上一个号
    private int lastNumber = 1;
    //正在排队服务的号
    private List<Integer> quenceNumber = new ArrayList<Integer>();
    //收集叫号机器打印出来的所有的号码
    public synchronized Integer generateNewManager(){
        quenceNumber.add(lastNumber);
        return lastNumber++;
    }
    //窗口人员拿号码,这里用integer是防止空指针异常的出现
    public synchronized Integer fetchServiceNumber(){
        Integer number = null;
        if(quenceNumber.size()>0)
          number = quenceNumber.remove(0);
        return number;
    }
}

package cn.wjd.bank;

public class NumberMachine {
    //3种不同类型的业务号码
    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 getInstance(){
        return instance;
    }
    private static NumberMachine instance = new NumberMachine();
}

package cn.wjd.bank;

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

public class ServiceWindow {
    //默认的是普通的客户
    private CustomerType type = CustomerType.COMMON;
    //记录窗口的ID
    private int windowID = 1;
    //设置客户的类型
    public void setType(CustomerType type) {
        this.type = type;
    }

    public void setWindowID(int windowID) {
        this.windowID = windowID;
    }

    public void commonService() {
        String windowName = "第" + windowID + "号" + type + "窗口";
        System.out.println(windowName + "正在获取任务");
        Integer number = NumberMachine.getInstance().getCommonManager()
                .fetchServiceNumber();
        if (number != null) {
            System.out.println("正在为"+windowID+"号客户");
            long beginTime = System.currentTimeMillis();
            int maxRan = Constants.MAX_SERVICE_TIME
                    - Constants.MIN_SERVICE_TIME;
            long serveTime = new Random().nextInt(maxRan) + 1
                    + Constants.MAX_SERVICE_TIME;
            try {
                Thread.sleep(serveTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long costTime = System.currentTimeMillis() - beginTime;
            System.out.println(windowName + "为第" + number + "个" + type
                    + "客户完成服务,耗时" + costTime / 1000);
        } else {
            System.out.println("没有取到任务,先休息1秒钟");
            //普通客户没服务的时候,可以用sleep来模拟休息
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public 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 costTime = System.currentTimeMillis() - beginTime;
            System.out.println(windowName + "为第" + number + "个" + type
                    + "客户完成服务,耗时" + costTime / 1000);
        } else {
            System.out.println("没有取到任务"+windowName);
            //快速服务根据需求,没有VIP服务的时候,需要为普通的服务
            commonService();
        }
    }
    
    public void VIPService() {
        String windowName = "第" + windowID + "号" + type + "窗口";
        System.out.println(windowName + "正在获取任务");
        //得到VIP的号码
        Integer number = NumberMachine.getInstance().getVIPManager()
                .fetchServiceNumber();
        if (number != null) {
            //记录时间
            long beginTime = System.currentTimeMillis();
            int maxRan = Constants.MAX_SERVICE_TIME
                    - Constants.MIN_SERVICE_TIME;
            long serveTime = new Random().nextInt(maxRan) + 1
                    + Constants.MAX_SERVICE_TIME;
            try {
                Thread.sleep(serveTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long costTime = System.currentTimeMillis() - beginTime;
            System.out.println(windowName + "为第" + number + "个" + type
                    + "客户完成服务,耗时" + costTime / 1000);
        } else {
            System.out.println(windowName +"没有取到任务");
            //VIP根据需求,没有VIP服务的时候,需要为普通的服务
            commonService();
        }
    }
//JDK1.5线程池的概念,3个类型的客户在同一线程中,内部类的使用简化了代码的书写
    public void start() {
        Executors.newSingleThreadExecutor().execute(new Runnable() {

            public void run() {
                while (true) {
                    switch (type) {
                    case COMMON:
                        commonService();
                        // String windowName = "第" + windowID + "号" + type +
                        // "窗口";
                        // System.out.println("正在获取任务");
                        // Integer number = NumberMachine.getInstance()
                        // .getCommonManager().fetchServiceNumber();
                        // if (number != null) {
                        // long beginTime = System.currentTimeMillis();
                        // int maxRan = Constants.MAX_SERVICE_TIME
                        // - Constants.MIN_SERVICE_TIME;
                        // long serveTime = new Random().nextInt(maxRan) + 1
                        // + Constants.MAX_SERVICE_TIME;
                        // try {
                        // Thread.sleep(serveTime);
                        // } catch (InterruptedException e) {
                        // e.printStackTrace();
                        // }
                        // long costTime = System.currentTimeMillis()
                        // - beginTime;
                        // System.out.println(windowName + "为第" + number + "个"
                        // + type + "客户完成服务,耗时" + costTime / 1000);
                        // } else {
                        // System.out.println("没有取到任务,先休息1秒钟");
                        // try {
                        // Thread.sleep(1000);
                        // } catch (InterruptedException e) {
                        // e.printStackTrace();
                        // }
                        // }
                        break;
                    case EXPRESS:
                        expressService();
                        break;
                    case VIP:
                        VIPService();
                        break;
                    }
                }
            }

        });

    }
}

package cn.wjd.bank;
//枚举,由于这3个类型的客户都是固定死的,所以可以使用枚举
public enum CustomerType {
    COMMON,EXPRESS,VIP;
    //英文对应中文,在ServiceWindow类中需要打印各个的枚举对于的中文内容
    public String toString(){
        switch(this){
           case COMMON:
               return "普通";
           case EXPRESS:
               return "快速";
           case VIP:
               return "VIP";
        }
        return null;
    }
}

package cn.wjd.bank;
//一些用来设置服务时间的常量
public class Constants {
    public static int MAX_SERVICE_TIME = 10000;
    public static int MIN_SERVICE_TIME = 1000;
    public static int COMMON_TIME = 1;
}

package cn.wjd.bank;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
//运行类
public class MainClass {

    /**
     * @param args
     */
    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            ServiceWindow commonWindow = new ServiceWindow();
            commonWindow.setWindowID(i);
            commonWindow.start();
        }
        
        ServiceWindow expressWindow = new ServiceWindow();
        expressWindow.setType(CustomerType.EXPRESS);
        expressWindow.start();
        
        ServiceWindow vipWindow = new ServiceWindow();
        vipWindow.setType(CustomerType.VIP);
        vipWindow.start();
    //新的线程技术,来模拟顾客进入的时间    
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable(){

                    public void run() {
                    Integer number = NumberMachine.getInstance().getCommonManager().generateNewManager();
                    System.out.println(number +"号普通客户等待服务");
                    }
                    
                },
                0,
                Constants.COMMON_TIME * 6,
                TimeUnit.SECONDS);
        
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable(){

                    public void run() {
                    Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();
                    System.out.println(number +"号快速客户等待服务");
                    }
                    
                },
                0,
                Constants.COMMON_TIME * 2,
                TimeUnit.SECONDS);
        
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable(){

                    public void run() {
                    Integer number = NumberMachine.getInstance().getVIPManager().generateNewManager();
                    System.out.println(number +"号普通客户等待服务");
                    }
                    
                },
                0,
                Constants.COMMON_TIME * 6,
                TimeUnit.SECONDS);
    }

}

4, 总结

     先说这两个7K的面试题吧,以前在学习的时候,一直在记忆Java语言的各种使用的规范,直到看了张老师这2个7k的面试题,记得刚开始自学毕向东老师的Java视频的时候,在前期讲解的面向对象的思想的时候,当时觉得这个很些很简单,只需要记忆的知识点而已,直到现在,通过这2个7K的面试题,面向对象的设计真的是程序员在设计程序时候的一种感觉,当然这种感觉是建立在自身阅读大量的源代码和不断的学习的过程中的.

在7k面试题中,我觉得涉及到最多的知识点分别是枚举,包括枚举中的构造方法如何去巧妙的设计,多线程中线程池的概念,还有张老师自创的多线程定时炸弹的概念.

     再说下自身的情况吧,从7月辞职,在家中自学毕老师的Java视频,从集合开始,到IO,网络编程,在回到多线程,花了大概2/3月的时间,目前正在查漏补缺,好好准备下面的入学考试和面试,这次已经把状态调到跟高三那会一样的状态了,但愿在之后的入学考试和面试中有个好的表现.