黑马程序员—7K 银行业务调度系统模拟

最新推荐文章于 2014-08-28 23:00:58 发布

原创最新推荐文章于 2014-08-28 23:00:58 发布 · 462 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一个银行调度系统的模拟实现，包括三个类型的客户（VIP、普通、快速）和六种业务窗口，通过多线程和面向对象的设计实现了业务调度逻辑。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

银行调度系统

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

银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。
异步随机生成各种类型的客户，生成各类型用户的概率比例为：
VIP客户：普通客户：快速客户 = 1 ：6 ：3。
客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，
快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。
各类型客户在其对应窗口按顺序依次办理业务。
当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，
而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。随机生成客户时间间隔以及业务办理时间
最大值和最小值自定，可以设置。不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

分析

首先根据题目的需求：我们要在需求条件中提取出语言所需要的信息。例如有6个窗口，有三类客户，

这里需要我们有良好的面向对象思想去剖析问题，哪些是类，而哪些是对象，哪些又是属性。

这道题若是在去过银行的人会更有体会，当下许多行业高度集成化，信息化。连银行排队这些小事也

不例外，取号机能够规范秩序，提升效率，降低管理和运营成本，也是讲求公平和现代化的一个命名。

那么这样的一个东西究竟是通过什么来实现的呢，这里要完成一个模拟，酷似与我们所学过的多线程

买票，而在此基础上多了一些更为复杂的操作。这里需要一点点的完成分析。

由于有三类客户，每一类的客户的号码编排都是独立的，所以推导出这个系统要产生三个号码管理器

对象，各自管理一类用户的排队号码，这三个号码管理器对象统一由一个号码机器进行管理。这个号码

机器在整个系统中始终只能有一个，所以。它要被设计成单例模式，单例模式有饿汉式，和懒汉式的区

别，此外，只有1个元素的枚举也是单例模式的一种体现。

分析完号码的操作，我们再分析柜台，各个窗口是如何知道该叫那个号的呢？它一定是通过相关的号

码管理器，既服务窗口每次通过号码管理器获取当前要被服务的号码。

假定有这么一台机器，它管理着三个号码，分属三种客户类。它有建立号码的权限，分发给客户，也

有取号的权限，能够将号码通知到窗口。简单说它就是能产生一个新的号码，并通知指定窗口为这个号

码进行服务。创建一个号码管理的类，分别实现三个差异化的子类。

根据以上分析出来的结果，我们写一个类：

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

public class NumberManager {
	private int lastNumber=1;
	/*另外，面向接口编程，可以兼容的类型更多变。且在定义类型的时候，尽量向父类超类上级方面靠*/
	private  List <Integer> queueNumbers = new ArrayList<Integer>();	//因为有排队问题，所以定义一个动态的数组，集合。
	
	public synchronized Integer generateNewManager(){	//这个方法的作用是产生一个整数，这个数可以是1，可以是2，是一个变量。用于服务客户
		queueNumbers.add(lastNumber);		//将产生的数据存起来，
		return lastNumber++;			
	}
//现在有了两个方法，并分属两个不同的线程，两个不同的线程访问了相同的数据就会出问题，这个什么我们就要考虑线程同步问题了 、
//如何解决，加上一个关键字 synchornized,让它们互斥。
	//产生了一个号码之后，是不是还有一个方法，要有取号的动作呢？
	//写一个方法，取要服务的号
	public synchronized Integer fetchServiceNumber(){		//产生号码不等于就可以服务了，考虑排队问题。在要服务的窗口的基础上+1次，用于服务窗口
		if(queueNumbers.size()>0){  
            return (Integer)queueNumbers.remove(0);  
        }else{  
            return null;  
        } 
	//这是集合中那个取走的值，取号动作，取馒头思想		
	}
	
}
//上面产生号码和取号中虽然是整数，还是用的整数的泛型，Integer，自动拆装箱，能够避免null异常

号码生成机制作完了，但是需要对此进行管理，那么还要做一个控制器，对三类号码进行管理。

写一个控制号码的机器：

public class NumberMachine {
//因为这个机器有三类数据要进行返回，那么它有三个管理器
	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;
	}
//NumberMachine 是一个类，它在这题中只能有一个对象，那么我们要把它做成一个单例，要分两个步骤，先做成对象，在做成单例
	private NumberMachine(){}			
	//单例的话，首先是构造方法私有化，这样别人就没法创建它。如果别人要用他的方法，那么只能用静态的方法。
	public static NumberMachine getInstance(){
		return instance;
	}
	//这个方法返回一个对象，这个对象由它本身创建的
	private static NumberMachine  instance= new NumberMachine();  //加静态是为了在对象还没有出来之前就已经存在,便于返回对象
}

写好号码管理器，我们还要完成一个服务窗口：

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

public class ServiceWindow {
	private CustomerType type = CustomerType.COMMON;
	// 而由于普通窗口有4个，纠结是哪一个在执行也不一定，所以也定义一个变量
	private int windowId = 1;
	

	public void setType(CustomerType type) { // 之所以要对上面两个变量进行set方法的设置，是这样窗口更灵活。有可能成为其他窗口
		this.type = type;
	}

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

	// 既然是一个服务窗口，那么有什么方法呢？ 叫号，有一个启动线程。
	public void start() {
		// jdk1.5的新特性，线程池 这里创建线程采用Runnable的方式。
		Executors.newSingleThreadExecutor().execute(new Runnable() {
			public void run() {
				while (true) {
					// 机器调用实例，再调用本类中的获取号码的方法，用那个方法呢？就要看窗口是那种类型的窗口、
					// if语句的效率比switch低。
					switch (type) {
						case COMMON:
							commonService();
						break;
						case EXPRESS:
							expressService();
						break;
						case VIP:
							vipService();
						break;
						default:
						break;
					}
				}
			}
		}
		);
	}
		
			private void commonService() {
				String windowName = "第" + windowId + "号" + type+ "窗口";
				Integer serviceNumber = NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
				System.out.println(windowName + "正在获取普通任务");
				if (serviceNumber != null) {
					System.out.println(windowName + "正在为第" + serviceNumber + "个普通客户服务");
					 // 由于服务需要花费时间，下面需要一个线程才操纵
					int maxRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
					int serveTime = new Random().nextInt(maxRand) + 1+ Constants.MIN_SERVICE_TIME;
					try {
						Thread.sleep(serveTime);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(windowName + "为第" + serviceNumber + "个" +  "普通客户完成服务，耗时" + serveTime / 1000 + "秒");
				} else {
					System.out.println(windowName + "没有取到普通服务任务,休息一秒");
					try {
						Thread.sleep(1000);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
	

			private void expressService() {
				String windowName = "第" + windowId + "号" + type+ "窗口";
				Integer serviceNumber = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
				System.out.println(windowName + "正在获取快速任务");
				if (serviceNumber != null) {
					System.out.println(windowName + "正在为第" + serviceNumber + "个"+ type + "客户服务");
					int serveTime=Constants.MIN_SERVICE_TIME;
					try {
						Thread.sleep(Constants.MIN_SERVICE_TIME);
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println(windowName + "为第" + serviceNumber + "个" + type+ "客户完成服务，耗时" + serveTime / 1000 + "秒");
				} else {
					System.out.println(windowName + "没有取到快速服务任务");
					commonService();
				}
			}

			private void vipService() {
				String windowName = "第" + windowId + "号" + type+ "窗口";
				Integer serviceNumber = NumberMachine.getInstance().getVipManager().fetchServiceNumber();
				System.out.println(windowName + "正在获取VIP任务");
				if (serviceNumber != null) {
					System.out.println(windowName + "正在为第" + serviceNumber + "个"+ type + "客户服务");
					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;	 
					try {
						Thread.sleep(serveTime);
					} catch (Exception e) {
						e.printStackTrace();
					}
					long costTime = System.currentTimeMillis() - beginTime;
					System.out.println(windowName + "为第" + serviceNumber + "个" + type+ "客户完成服务，耗时" + serveTime / 1000 + "秒");
				} else {
					System.out.println(windowName + "没有取到VIP服务任务");
					commonService();
				}
			}
}

窗口完成，这个时候发现三个窗口几乎没有太多区别，不同的是快速窗口和VIP窗口多了一个

回溯普通窗口的动作，那么也可以就此换个思路，快速窗口和VIP窗口都是普通窗口的子类。思路

有了，只需要在继承中重写我们需要的部分。

一些对象需要我们进行补充，用枚举列出：

public enum CustomerType {//可以理解为不同的接待窗口，但是顾客类型显然更恰当
	COMMON,EXPRESS,VIP;
	//枚举中type的返回值有个toString方法，返回值就是其某个对象的名字，考虑中文提示的问题，可以重写toString方法
	public String toString(){
		switch (this) {
		case COMMON:
			return "普通";
		case EXPRESS:
			return "快速";
		case VIP:
			return name();  //返回自己的名字，枚举中的一个方法
		}
		return null;      //确保万一，switch语句中要有一个默认或者预定于的 break，或者return。
	}
	
}

将最大值和最小值设定成常量：

public class Constants {
	public static int MAX_SERVICE_TIME=10000;
	public static int MIN_SERVICE_TIME=1000;
	public static int COMMON_CUSTOMER_INTERVAL_TIME=1;
	
}

最后是开主方法：

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

public class mainClass {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i = 1; 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_CUSTOMER_INTERVAL_TIME,
		TimeUnit.SECONDS
		); // 创建了一个大小为1的线程,引用一个定时启动方法,模拟了普通客户的入场
		
		//产生快速客户
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
			public void run() {
				Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();
				System.out.println(number + "号快速客户等待服务");
			}
		}, 
		0,
		Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,
		TimeUnit.SECONDS
		);
		
		//产生VIP
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
			public void run() {
				Integer number = NumberMachine.getInstance().getVipManager().generateNewManager();
				System.out.println(number + "号VIP客户等待服务");
			}
		},
		0,
		Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,
		TimeUnit.SECONDS
		);
	}
}

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------详细请查看： http://edu.youkuaiyun.com