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

最新推荐文章于 2015-12-24 10:26:47 发布

DonSen29

最新推荐文章于 2015-12-24 10:26:47 发布

阅读量596

点赞数

分类专栏：学习笔记文章标签： java 黑马程序员面向对象多线程

本文链接：https://blog.csdn.net/u013759420/article/details/20302069

版权

学习笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

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

需求:

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

涉及:

面向对象的分析和设计

           有三种对应类型的客户: vip客户,普通客户,快速客户,异步随机生成各种类型的客户,
                               各类型客户在其对应窗口按顺序依次办理业务.

       客户的生成:
                   银行有一个号码生成器,让这个对象不断的产生号码,就等于随机生成客户.
                   三类客户有三各号码管理器,三个号码管理器统一由一个号码器管理,这一个
                   号码器在整个系统中只能有一个,所以,它要被设计成单例.

                   NumberManager   ->|generateNumber()
                                        |fetchNumber()
                   NumberMachine   ->|getCommonManager()
                                        |getVipManager()
                                        |getExpressManager()
                                        |getInstance()
                   ServiceWindow   ->|start()
                                        |commonService()
                                        |expressService()
                                        |vipService()

    创建一个线程池,运行一个线程
       Executors.newSingleThreadExecutor().execute(new Runnable(){
               public void run(){

               }
           }
       );

    创建调度线程池,运行一个线程,以固定的频率运行:
       Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
           new Runnable(){               //线程
               public void run(){}
           },
           0,                   //第一次延迟多长时间运行,延迟initial delay
           1,                   //以后每隔多长时间运行
           TimeUnit.SECONDS   //设置上面数值的单位
       );

类实现:

NumberManager类
1.用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。
2.定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步。

public class NumberManager {
	private int lastNumber=1;
	private List <Integer>queueNumber=new ArrayList<Integer>();
	// 添加线程
	public synchronized Integer generateNewManger(){
		queueNumber.add(lastNumber);
		return lastNumber++;
	}
	// 取出线程
	public synchronized Integer fetchServiceNumber(){
		Integer number=null;
		if(queueNumber.size()>0){
			number=queueNumber.remove(0);
		}
		return number;
	}
}

NumberMachine类

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

/**
 * 取号器（单例）
 */
public class NumberMachine {
	private NumberManager commonManger =new NumberManager();
	private NumberManager expressManger =new NumberManager();
	private NumberManager vipManger =new NumberManager();
	// 分三个排号器
	public NumberManager getCommonManger() {
		return commonManger;
	}
	public NumberManager getExpressManger() {
		return expressManger;
	}
	public NumberManager getVipManger() {
		return vipManger;
	}
	//单例设计模式
	private NumberMachine(){}
	private static NumberMachine instance=new NumberMachine();
	public static NumberMachine getInstance(){return instance;}
}

CustomerType枚举类

1.系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户。
2.重写toString方法，返回类型的中文名称。这是在后面编码时重构出来的，刚开始不用考虑。

/**
 * 客户类型
 */
public enum CustomerType {
	COMMON,EXPRESS,VIP; 
	public String toString(){
		switch(this){
		case COMMON:return"普通";
		case EXPRESS:return"快速";
		case VIP:return name();
		}
		return null;
	}
}

ServiceWindow类
1.定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。
2.定义三个方法分别对三种客户进行服务，为了观察运行效果，应详细打印出其中的细节信息。

/**
 * 服务窗口
 */
public class ServiceWindow {
	//服务窗口类型
	private CustomerType type=CustomerType.COMMON;
	//窗口
	private int windowId=1;
	//设置窗口类型
	public void setType(CustomerType type) {this.type = type;}
	//设置窗口
	public void setWindowId(int windowId) {this.windowId = windowId;}
	//启动服务
	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:			//VIP服务
				    vipService();
				    break;
			    }
			}
		    }
		});
	}
	//普通服务
	private void commonService(){
		String windowName="第"+windowId+"号"+type+"窗口";
		Integer number=NumberMachine.getInstance().getCommonManger().fetchServiceNumber();
		System.out.println(windowName+"正在获取普通任务！");
		if(number!=null){
			System.out.println(windowName+"为第"+number+"个"+"普通客户服务！");
			int maxRand=Constances.MAX_SERVICE_TIME-Constances.MIN_SERVICE_TIME;
			long beginTime =System.currentTimeMillis();
			long serveTime=new Random().nextInt(maxRand)+1+Constances.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serveTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			long costTime=System.currentTimeMillis()-beginTime;
			System.out.println(windowName+"为第"+number+"个"+"普通"+
				    "客户完成服务，耗时"+(costTime)/1000+"秒");
			}else{
				System.out.println(windowName+"没有取到服务任务,先休息一秒钟！");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	//快速服务
	private void expressService(){
		    String windowName="第"+windowId+"号"+type+"窗口";
		    Integer number=NumberMachine.getInstance().getExpressManger().fetchServiceNumber();
		    System.out.println(windowName+"正在获取快速任务！");
		    if(number!=null){
			    System.out.println(windowName+"为第"+number+"个"+"快速客户服务！");
			    long beginTime =System.currentTimeMillis();
			    try {
				    Thread.sleep(Constances.MIN_SERVICE_TIME);
			    } catch (InterruptedException e) {
				    e.printStackTrace();
			    }
			    long costTime=System.currentTimeMillis()-beginTime;
			    System.out.println(windowName+"为第"+number+"个"+
				    "快速"+"客户完成服务，耗时"+(costTime)/1000+"秒");
		     }else{
			    System.out.println(windowName+"没有取到服务任务!");
			    commonService();
		    }
	    }
	//VIP服务
	private void vipService(){
		String windowName="第"+windowId+"号"+type+"窗口";
		Integer number=NumberMachine.getInstance().getVipManger().fetchServiceNumber();
		System.out.println(windowName+"正在获取VIP任务！");
		if(number!=null){
			System.out.println(windowName+"为第"+number+"个"+"Vip客户服务！");
			int maxRand=Constances.MAX_SERVICE_TIME-Constances.MIN_SERVICE_TIME;
			long beginTime =System.currentTimeMillis();
			long serveTime=new Random().nextInt(maxRand)+1+Constances.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serveTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			long costTime=System.currentTimeMillis()-beginTime;
			System.out.println(windowName+"为第"+number+"个"+
				    "Vip"+"客户完成服务，耗时"+(costTime)/1000+"秒");
			}else{
				System.out.println(windowName+"没有取到服务任务!");
				commonService();
			}
		}
	}
}

Constants类
1.定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

/**
 * 与客户相关的常量
 */
public class Constances {
        //最大客户服务时间
        public static int MAX_SERVICE_TIME=10000;
        //最小客户服务时间
        public static int MIN_SERVICE_TIME=1000;
        //随机产生客户的时间基础数
        public static int COMMON_CUSTOMER_INTERVAL_TIME=1;
}

MainClass类

1.用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。

2.接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

public class MainClass {
         /**
* @param args
*/
public static void main(String[] args) {
        //产生4个普通窗口
        for(int i=1;i<5;i++){
            ServiceWindow commonwindow=new ServiceWindow();
            commonwindow.setWindowId(i);
            commonwindow.start();
        }
        //产生1个快速窗口
        ServiceWindow expresswindow=new ServiceWindow();
        expresswindow.setType(CustomerType.EXPRESS);
        expresswindow.start();
        //产生1个VIP窗口  
        ServiceWindow vipwindow=new ServiceWindow();
        vipwindow.setType(CustomerType.VIP);
        vipwindow.start();
        //普通客户拿号
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable(){
                        public void run(){
                                Integer number=NumberMachine.getInstance().getCommonManger().generateNewManger();
                                System.out.println("第"+number+"号普通客户等待服务");
                        }
                }, 
                0,
                Constances.COMMON_CUSTOMER_INTERVAL_TIME, 
                TimeUnit.SECONDS
          );
        //快速客户拿号
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable(){
                        public void run(){
                                Integer number=NumberMachine.getInstance().getExpressManger().generateNewManger();
                                System.out.println("第"+number+"号快速客户等待服务");
                        }
                }, 
                0,
                Constances.COMMON_CUSTOMER_INTERVAL_TIME*2, 
                TimeUnit.SECONDS
        );
        //VIP客户拿号
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                new Runnable(){
                        public void run(){
                                Integer number=NumberMachine.getInstance().getVipManger().generateNewManger();
                                        System.out.println("第"+number+"号VIP客户等待服务");
                        }
                }, 
                0,
                Constances.COMMON_CUSTOMER_INTERVAL_TIME*6, 
                TimeUnit.SECONDS
        );
    }
}

上面的例子是张孝祥老师的经典案例,根据老师的设定的思路,

我自己用

等待唤醒机制的方式 ,

从新做了一次,实现代码如下:

CustomerGenerative.java

//这个类中有3个模拟客户队列的集合

package cn.itheima.wxn.bankQueue;
import java.util.List;
import java.util.Random;
//产生客户,按6:3:1的几率产生客户
class CustomerGenerative implements Runnable {
	private List<Integer> common;
	private List<Integer> express;
	private List<Integer> vip;
	//构造方法,接收3个模拟队列的集合
	CustomerGenerative(List<Integer> list1, List<Integer> list2,
			List<Integer> list3) {
		this.common = list1;
		this.express = list2;
		this.vip = list3;
	}	
	@Override
	public void run() {
		int commonCount = 0;	//统计总的普通客户的人数
		int expressCount = 0;	//统计中的快速客户的人数
		int vipCount = 0;	//统计总的vip客户的人数
		Integer num = 0;		//递增的索引,可以表示总的客户的人数
		Random r = new Random();
		while (true) {
			//每当有10的倍数个客户进入的时候,输出统计信息
			if(num%10 == 0){
				System.out.println("=====查看排队用户信息=======");
				System.out.println(this.common + "全部的普通客户有:" + commonCount + "人");
				System.out.println( this.express+ "全部的快速客户有:" + expressCount + "人");
				System.out.println( this.vip+ "全部的VIP客户有:" + vipCount + "人");				
				System.out.println("=======================");
			}
			num++;
			//进程睡眠2秒
			try {
				Thread.sleep(r.nextInt(2000));
			} catch (Exception ex) {
				ex.printStackTrace();
			}
			//flag用于判断是添加那种类型的客户
			int flag = r.nextInt(10);	//取0~10之间的随机数,随机数是0~5,是普通客户;6~8是快速客户;9是vip客户
			if (flag < 6) {
				common.add(num);
				System.out.println("======>" +num + "号普通客户等待");
				commonCount++;
				synchronized (common) {
					this.common.notifyAll();
				}
			} else if (flag >= 6 && flag < 9) {
				express.add(num);
				System.out.println("======>" +num + "号快速客户等待");
				expressCount++;
				synchronized (express) {
					this.express.notifyAll();
				}
			} else {
				vip.add(num);
				System.out.println("======>" + num + "号VIP客户等待");
				vipCount++;
				synchronized (vip) {
					this.vip.notifyAll();
				}
			}
		}
	}
}

WindowType.java 窗口类型的enum

package cn.itheima.wxn.bankQueue;

public enum WindowType {
	COMMON,EXPRESS,VIP;
	
	public String toString(){
		switch(this){
		case COMMON:
			return "普通";
		case EXPRESS:
			return "快速";
		case VIP:
			return "VIP";
		}
		return null;
	}
}

WindowService.java

package cn.itheima.wxn.bankQueue;
import java.util.List;
import java.util.Random;
class WindowService implements Runnable {
	private List<Integer> common;
	private List<Integer> express;
	private List<Integer> vip;
	private String name;
	private WindowType type;
	//无参构造方法
	WindowService() {}
	//构造方法
	WindowService(List<Integer> common, List<Integer> express,
			List<Integer> vip, WindowType type, int count) {
		//接收三个模拟队列的集合
		this.common = common;
		this.express = express;
		this.vip = vip;
		//指定本窗口的类型
		this.type = type;
		//指定窗口的名称
		this.name = count + "号" + this.type + "窗口";
	}
	/**
	 * @see 窗口的服务方法
	 *@param list:方法接收一个模拟队列的集合,
	 *@param radix: 服务的时间等级, 这个等级没有限制,自己微调,表示服务时间的长短
		@return false,表示没有客户,返回true表示已经服务完客户
	*/
	public boolean serveCustomer(List<Integer> list, int radix) {
		Random r = new Random();	
		Integer num = null;	//接收从集合中取出的客户的编号
		//同步代码块,从集合中取元素的功能,
		synchronized (list) {
			//如果集合中没有元素的情况下,窗口要么等待,要么接收其他客户队列的服务请求
			while (list == null || list.isEmpty() || (num = list.remove(0)) == null) {
				//如果本窗口不是普通窗口并且客户队列不是普通队列,返回false
				if (!this.type.equals(WindowType.COMMON) && list != this.common){
					System.out.println("\t~!@#$%^&**()" + this.name + "没能获取相应客户");
					return false;
				}
				//窗口等待
				try {
					System.out.println("\t[" + this.name + "等待客户******");
					list.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		//根据取出的编号得到客户的名称
		StringBuilder customer = new StringBuilder("");
		customer.append(num + "号");
		if (list == common) {
			customer.append("普通客户");
		} else if (list == express) {
			customer.append("快速客户");
		} else {
			customer.append("vip客户");
		}
		System.out.println(this.name + "开始为" + customer.toString()	+ "服务---------->");
		//根据传递进来的radix让线程睡眠多少秒,表示服务正在进行
		int time = 0;
		try {
			time = r.nextInt(radix) + 2;
			Thread.sleep(time * 1000);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		System.out.println(this.name + "结束了为" + customer.toString() + "的服务,耗时" + time + "秒<-----------");
		return true;
	}
	/**
	 * run方法根据本窗口的类型,分情况调用上面的服务方法
	 */
	@Override
	public void run() {
		while (true) {
			switch (type) {
			case COMMON:
				serveCustomer(common, 7);
				break;
			case EXPRESS:
				//快速窗口没有接受到快速客户队列的服务请求的时候,可以接受普通客户队列的请求
				if (!serveCustomer(express, 1)) {
					serveCustomer(common, 4);
				}
				break;
			case VIP:
				//vip窗口没有接受到vip客户队列的服务请求的时候,可以接受普通客户队列的请求
				if (!serveCustomer(vip, 4)) {
					serveCustomer(common, 5);
				}
				break;
			}
		}
	}
}

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

DonSen29

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员--银行业务调度系统

-------------android培训、java培训、期待与您交流！---- -----需求: 1.银行内有6个业务窗口,1-4号窗口为普通窗口,5号为快速窗口,6号为vip窗口 2,有三种对应类型的客户:vip客户,普通客户,快速客户(办理如交水电费,电话费之类的业务的客户) 3,异步随机生成各种类型的客户,生成各类
复制链接

扫一扫