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

于 2013-04-06 21:37:46 发布
阅读量624 收藏
点赞数
分类专栏： java项目实践
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yueyushanhe/article/details/8765108
版权
------- android培训、 java培训、期待与您交流！ ----------

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

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

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

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

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

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

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

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

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

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


分析：
银行的每个客户其实都是由一个号码生成器生成的号码来表示的。而根据不同的要求，分为三种不同类型的客户：普通客户、快速客户、VIP客户。
而三种客户的区分其实也就是不同的号码生成器来生成不同种类的号码来划分的。而号码生成器其实都是由一个号码管理器来管理的。这个号码
管理器在程序运行期间都是唯一的一个对象，可以用单例来表示。
而客户到不同的服务窗口去办理业务，也就是以不同窗口叫号的方式来体现的。因此按照要求，服务窗口有4个普通窗口，1个快速窗口以及一个VIP窗口。
不同客户办理业务的时间是随机的，但是快速窗口服务快速客户花费的时间最小。另外快速窗口和VIP窗口在空闲时间可以服务普通客户。

图例：


思路：
1.NumberManager类：定义一个存储客户号码的集合，内部包括了两个方法。分别是产生新号码的方法以及获取马上要被服务的客户的号码的方法。因为这两个
方法要被多个线程所调用，因此要同步。
2.NumberMachine类：因为所涉及的对象只有一个，因此设计成单例，必然有一个获取本类对象的静态方法。另外还有3个方法，分别是获取普通客户NumberManager的方法，获取快速客户NumberManager的方法以及获取VIP NumberManager的方法。
3.ServiceWindow类：定义了一个start方法，内部启动一个线程，根据不同客户分别采用不同的服务方法。定义了三种方法，分别对三种客户进行服务。不同的窗口服务不同的客户，而如果快速窗口和VIP窗口没有其对应的客户服务时，会服务普通的客户。如果都没有客户服务，会暂停1秒，然后再继续叫号。窗口服务客户的时间是随机的，通过Random对象来操作。
4.CustomerType枚举类：客户分为3种，通过枚举类来描述。重写了toString方法，返回对应的中文。
5.Contants常量类：用来定义需要的各种常量。
6.MainClass类：创建4个普通窗口，1个快速窗口和一个VIP窗口。再创建三个定时器，分别产生三种不同客户的号码。

代码：

NumberManager 类： 
package com.itheima;

import java.util.ArrayList;
import java.util.List;
/**
 * 号码生成器每生成一个号码就代表一个客户。内部定义了一个容器，用来存储客户号码。
 * 定义了两个方法，一个是产生新号码的方法，一个是获取马上要被服务的客户号码。
 * 因为两个方法会被多个线程调用，会涉及到共同数据，所以要加同步锁。
 */
public class NumberManager {
	List<Integer> contains = new ArrayList<Integer>();
	
	private Integer lastNumber = 1;
	/*产生新号码，存储在容器内。*/
	public synchronized Integer generateNewNumber(){
		contains.add(lastNumber);
		return lastNumber++;
	}
	/*获取马上被服务的号码，因为要调用remove方法，需要判断容器中是否有元素，如果容器为null，则返回null*/
	public synchronized Integer gainServiceNumber(){
		Integer number = null;
		if(contains.size()>0)
			number = contains.remove(0);
		return number;
	}
}

NumberMachine类： 
package com.itheima;

/**
 * 号码管理器在程序运行期间只有一个对象，因此设计成单例。
 * 有三个生成不同号码产生器(NumberManager)的方法,分别是commonNumberManager，
 * expressNumberManager，vipNumberManager。
 */
public class NumberMachine {
	/*定义三种客户类型的NumberManager对象*/
	private NumberManager commonNumberManager = new NumberManager();
	private NumberManager expressNumberManager = new NumberManager();
	private NumberManager vipNumberManager = new NumberManager();
	
	public NumberManager getCommonNumberManager() {
		return commonNumberManager;
	}
	public NumberManager getExpressNumberManager() {
		return expressNumberManager;
	}
	public NumberManager getVipNumberManager() {
		return vipNumberManager;
	}
	/*设置单例*/
	private NumberMachine(){}
	private static NumberMachine instance = new NumberMachine();
	/*获取NumberMachine对象的静态方法*/
	public static NumberMachine getInstance(){
		return instance;
	}
}

ServiceWindow类： 
package com.itheima;

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

/**
 * ServerWindow可被调用的只有start方法。start方法内部根据不同的CustomerType对应了3种方法。
 * 分别是commonService，expressService，vipService，为不同客户做出不同服务。
 * 因此又定义了一个枚举类CustomerType，用来描述不同客户。
 */
public class ServiceWindow {
	/*定义客户类型属性，默认为COMMON*/
	private CustomerType type = CustomerType.COMMON;
	/*定义服务窗口编号*/
	private int windowId;
	/*窗口编号的set方法*/
	public void setWindowId(int windowId) {
		this.windowId = windowId;
	}
	
	ServiceWindow(CustomerType type){
		this.type = type;
	}
	/*对外只提供start方法*/
	public void start(){
		/*创建一个线程，根据不同type，执行不同方法*/
		Executors.newSingleThreadExecutor().execute(new Runnable(){
			public void run(){
				while(true){
					/*判断type类型，执行对应的方法*/
					switch(type){
					case COMMON:
						commonService();
						break;
					case EXPRESS:
						expressService();
						break;
					case VIP:
						vipService();
						break;
					}
				}
			}
		});
	}
	/*普通客户服务方法*/
	private void commonService() {
		/*获取服务号码*/
		Integer number = NumberMachine.getInstance().getCommonNumberManager().gainServiceNumber();
		/*窗口名称*/
		String windowName = "第"+windowId+"号"+type+"窗口";
		System.out.println(windowName + "正在获取"+"普通"+"客户服务");
		/*判断number是否为null，如果不是null，则提供服务*/
		if(number!=null){
			System.out.println(windowName + "开始为第" + number + "号" + "普通" + "客户服务");
			/*获取随机的最大范围：最大服务时间减去最小服务时间*/
			int maxRandom = Contants.MAX_SERVICE_TIME-Contants.MIN_SERVICE_TIME;
			/*随机服务时间等于随机范围内的随机值加上最小服务时间*/
			int serverTime = new Random().nextInt(maxRandom)+1+Contants.MIN_SERVICE_TIME;
			try {
					Thread.sleep(serverTime);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println(windowName + "为第" + number + "号" + "普通" + "客户完成服务，共耗时" + serverTime/1000 + "秒");
		}
		/*如果number为null，先空闲1秒*/
		else{
			System.out.println(windowName + "没有取到服务，先休息1秒");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	/*快速客服服务方法*/
	private void expressService() {
		Integer number = NumberMachine.getInstance().getExpressNumberManager().gainServiceNumber();
		String windowName = "第"+windowId+"号"+type+"窗口";
		System.out.println(windowName + "正在获取"+type+"客户服务");
		if(number!=null){
			System.out.println(windowName + "开始为第" + number + "号" + type + "客户服务");
			/*服务时间为最小值*/
			int serverTime = Contants.MIN_SERVICE_TIME;
			try {
					Thread.sleep(serverTime);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println(windowName + "为第" + number + "号" + type + "客户完成服务，共耗时" + serverTime/1000 + "秒");
		}
		else{
			System.out.println(windowName + "没有取到服务，开始获取普通服务");
			/*没有取到本类服务，再获取普通客户服务*/
			commonService();
		}
	}
	/*vip客户服务方法*/
	private void vipService() {
		Integer number = NumberMachine.getInstance().getVipNumberManager().gainServiceNumber();
		String windowName = "第"+windowId+"号"+type+"窗口";
		System.out.println(windowName + "正在获取"+type+"客户服务");
		if(number!=null){
			System.out.println(windowName + "开始为第" + number + "号" + type + "客户服务");
			int maxRandom = Contants.MAX_SERVICE_TIME-Contants.MIN_SERVICE_TIME;
			/*服务时间和普通客户相同*/
			int serverTime = new Random().nextInt(maxRandom)+1+Contants.MIN_SERVICE_TIME;
			try {
					Thread.sleep(serverTime);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println(windowName + "为第" + number + "号" + type + "客户完成服务，共耗时" + serverTime/1000 + "秒");
		}
		else{
			System.out.println(windowName + "没有取到服务，开始获取普通服务");
			/*没有本类服务，也执行普通客户服务*/
			commonService();
		}
	}
}

CustomerType类： 
package com.itheima;

/*定义客户类型枚举类*/
public enum CustomerType {
	COMMON,EXPRESS,VIP;
	
	/*重写toString方法 打印成中文*/
	public String toString(){
		switch(this){//this代表枚举对象
		case COMMON:
			return "普通";
		case EXPRESS:
			return "快速";
		case VIP:
			return name();
		}
		return null;
	}
}

Contants类： 
package com.itheima;

/*常量类*/
public class Contants {
	/*最大服务时间*/
	public static int MAX_SERVICE_TIME = 10000;
	/*最小服务时间*/
	public static int MIN_SERVICE_TIME = 1000;
	/*普通客户生成间隔时间*/
	public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;
}

MainClass： 
package com.itheima;

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

public class MainClass {

	/**
	 * MainClass先创建4个普通窗口，1个快速窗口，1个vip窗口。
	 * 然后启动三个不同的定时器分别产生三种客户类型的号码。
	 * 生成各类型客户的概率比例为：vip客户 ：快速客户 ：普通客户 = 1:3:6.
	 */
	public static void main(String[] args) {
		/*for循环创建4个普通窗口*/
		for(int i=1;i<5;i++){
			ServiceWindow common = new ServiceWindow(CustomerType.COMMON);
			common.setWindowId(i);
			common.start();
		}
		/*创建1个快速窗口*/
		ServiceWindow express = new ServiceWindow(CustomerType.EXPRESS);
		express.setWindowId(1);
		express.start();
		/*创建1个vip窗口*/
		ServiceWindow vip = new ServiceWindow(CustomerType.VIP);
		vip.setWindowId(1);
		vip.start();
		/*生成普通客户号码*/
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						int number = NumberMachine.getInstance().getCommonNumberManager().generateNewNumber();
						System.out.println("第" + number + "号" + "普通" + "客户等待服务");
					}
				},
				0,
				Contants.COMMON_CUSTOMER_INTERVAL_TIME,//以普通客户号码产生间隔时间为基数，并设置成常量。
				TimeUnit.SECONDS
			);
		/*产生快速客户号码*/
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						int number = NumberMachine.getInstance().getExpressNumberManager().generateNewNumber();
						System.out.println("第" + number + "号" + "快速" + "客户等待服务");
					}
				},
				0,
				Contants.COMMON_CUSTOMER_INTERVAL_TIME * 2,//快速客户号码间隔时间为普通客户的2倍
				TimeUnit.SECONDS
		);
		/*产生vip客户号码*/
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						int number = NumberMachine.getInstance().getVipNumberManager().generateNewNumber();
						System.out.println("第" + number + "号" + "VIP" + "客户等待服务");
					}
				},
				0,
				Contants.COMMON_CUSTOMER_INTERVAL_TIME * 6,//vip客户号码间隔为普通客户的6倍
				TimeUnit.SECONDS
		);
	}

}

总结：
1.银行业务系统在多线程的使用时要考虑到对共享数据的处理，如果在共同调用的方法中使用了共享数据，则要加上同步，以防数据错乱。
2.对于3种不同客户类型，对应的操作需要分为3种。虽然可以提取共同功能，但根据银行窗口是可以做调整的，因此生成不同对应的方法
更加方便使用。
3.对于客户服务时间，应在常量类中定义最大值和最小值，然后根据随机范围，通过Thread.sleep()方法来设置随机服务时间。
4.获取到的将要被服务的客户号码可能为空，因为要对两种情况都做出考虑。
5.我在自己手写代码的过程中，NumberMachine类中定义了3个NumberManager变量，却没有赋值生成对象。导致程序运行时，出现NullPointException。
调试很长时间没有效果。所以细节方面一定需要注意。另外start方法中要有无限循环，来让整个程序不断运行。如果没有循环，每个窗口执行一次就会结束了。

yueyushanhe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值