黑马程序员_银行业务调度系统

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月的时间,目前正在查漏补缺,好好准备下面的入学考试和面试,这次已经把状态调到跟高三那会一样的状态了,但愿在之后的入学考试和面试中有个好的表现.

黑马程序员_银行业务调度系统,布布扣,bubuko.com

时间： 2024-10-04 01:10:10

黑马程序员_银行业务调度系统的相关文章

黑马程序员___银行调度业务系统

----------- android培训.java培训.java学习型技术博客.期待与您交流! --------- 模拟实现银行业务调度系统逻辑,具体需求如下: 银行内有6个业务窗口,1 - 4号窗口为普通窗口,5号窗口为快速窗口,6号窗口为VIP窗口. 有三种对应类型的客户:VIP客户,普通客户,快速客户(办理如交水电费.电话费之类业务的客户). 异步随机生成各种类型的客户,生成各类型用户的概率比例为: VIP客户 :普通客户 :快速客户  =  1 :6 :3. 客户办理业务所需时间有最大

黑马程序员_交通灯管理系统

(1)项目的需求 模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 例如: 由南向而来去往北向的车辆 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 平时开车过十字路口红绿灯的时候,也知道红绿灯运行的顺序 (1)任何方向的车,向右边转弯的时候,是不需要看红绿灯 (2)在十字路口,相对方向的红绿灯的工作方式是一样的,南相对与北,东相对与西,这把它分成两对 (3)红绿灯顺序,一对直行通道绿灯直行车辆,等直行变红,还是这对的车辆可以左转,等左转变红,就轮到下一对了.所以在设计程序的时候,只

黑马程序员_ 利用oc的协议实现代理模式

先说下代理模式是什么吧 定义: 为其他对象提供一种代理以控制对这个对象的访问.在某些情况下,一个对象不适合或者不能直接引用另一个对象 而代理对象可以在客户端和目标对象之间起到中介的作用. 在看过李明杰老师的课程后,我对代理模式有了最初步的理解,虽然还很浅显 但是也明白了代理模式的 一些作用跟用法.首先使用代理模式可以降低耦合度.大大的增强了代码的弹性. 举个例子,小明想看电影,但是没时间买票 于是就拜托小强去买票 最简单的方式就是 建立一个person类(小明) 一个agent类(代理类) ag

黑马程序员_毕向东_Java基础视频教程_Java基础学习知识点总结

黑马程序员_毕向东_Java基础视频教程 Java基础学习知识点总结 2016年01月06日  day01 一.基础知识:软件开发 1.什么是软件?软件:一系列按照特定顺序组织的计算机数据和指令的集合. 2.常见的软件:系统软件:如:DOS,Windows,Linux等.应用软件:如:扫雷,迅雷,QQ等. 3.什么是开发?制作软件. 二.基础知识:人机交互方式 4.软件的出现实现了人与计算机之间的更好的交互. 5.交互方式:图形化界面:这种方式简单直观,使用者易于接受,容易上手操作.命令行方式:

黑马程序员_高新技术_1_Java反射

------- android培训.java培训.期待与您交流! ---------- 0.反射知识体系 下图为反射整体的知识体系,把握住此图也就全局上掌握住反射所有内容. 1.反射概论 1)反射概念 其实字面上可以这么理解反射,平时使用类时都是由类new出对象,而反射则是通过对象"反射"出类的信息,好比一个人照镜子可以看到人类的特征,而看出机制就是镜子反射. 2)Java对象两种类型 Java程序中的许多对象在运行时会出现两种类型:编译时类型和运行时类型.如下代码: Person p

黑马程序员_第一天视频学习

一.      计算机和软件常识 1.      计算机运行原理 1)          硬件基本组成:硬盘.内存.CPU 2)          各个部件之间的运作协调(下图) 2.      计算机只能识别0和1 1)          0和1组成的指令 2)          0和1组成的数据 3.      计算机和软件的联系 1)          软件的基本概念:指令的集合 2)          软件的安装运行过程 3)          为什么要开发软件:写出能控制计算机的指令

黑马程序员_类加载机制

------- android培训.java培训.期待与您交流! ---------- 0.类加载机制知识体系 1.类与JVM进程 使用Java命令运行某个Java程序时,此命令会启动一个Java虚拟机进程,不管Java程序多复杂,开启了多少个线程,这个线程都运行在Java虚拟机进程里.同一个JVM的所有线程.所有变量都处于同一个进程里,都使用该JVM进程的内存区. 只有出现下列情况时,JVM进程才会终止: 1)程序正常结束. 2)程序执行到代码System.exit()或Runtime.get

黑马程序员_集合

集合1.集合和对象数组的区别: 数组的长度不可变,集合的可变: 数组可以存储基本数据类型和对象,集合只能存储对象. 集合的框架图 集合派系的顶层接口Collection1.Collection集合存储对象的方法: add(E e)将元素存储到集合中 addAll(Collection c)将一个集合添加到另外的集合中2.Collection集合提取对象的方法: 通过迭代器iterator中的方法:hasNext()和next()来取出 Iterator it=new iterator(); wh

黑马程序员_学习IOS之字典常用的方法

字典是无序的 数组是有序的.字典分为:可变字典和不可变字典  不可变字典对象 NSDictionary * dict = [[NSDictionary alloc]initWithObjectsAndKeys:@"one",@"1",@"two",@"2",@"three",@"3",@"four",@"4", nil]; //value = ke