破解面试题2_银行业务调度系统_可随机产生(比如;1表示vip顾客;0表示普通顾客)的代码-优快云博客

本文链接：https://blog.youkuaiyun.com/shang1jk/article/details/9155567

一、项目需求

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

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

二、分析解决

1. 面向对象的分析与设计:

有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。
要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。
* 由于有三类客户，每类客户的号码编排都是完全独立的，所以，本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。
各类型客户在其对应窗口按顺序依次办理业务，准确地说，应该是窗口依次叫号。各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

2. 类图:

3. NumberManager类的分析编写:

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

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


public class NumberManager 
{
    private List<Integer> customer = new ArrayList<Integer>() ;

    private int latestCustomer = 1 ;

    public synchronized Integer addInstance()
    {
        customer.add(latestCustomer) ;

        return latestCustomer++ ;
    }

    //因为每种类型的窗口要服务的顾客类型都是一致的,所以相同的窗口类型就要共用一个号码管理器的列表.
    //因此比如: 如果有6个普通用户窗口,那这6个普通用户窗口在空闲的时候,都是检索同一个号码管理器中的队列
    //            进行添加的时候也是这样的..因此,addInstance和getInstance的方法就需要被多个窗口线程所共享.
    //            所以要对addInstance()和getInstance()进行同步
    public synchronized Integer getInstance()
    {
        if (customer.size() <= 0)
        {
            return null ;
        }
        return customer.remove(0) ;
    }
}

4. NumberMachine类的分析编写:

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

class NumberMachine
{
    private static NumberMachine instance = new NumberMachine() ;

    //定义银行中的各个服务窗口所需要的服务列表
    private NumberManager commonManager = new NumberManager() ;
    private NumberManager vipManager = new NumberManager() ;
    private NumberManager expressManager = new NumberManager() ;

    //每次新建完一个窗口,就要根据窗口的对应类型获取对应的窗口号码管理器
    //并且一定要保证该号码管理器是唯一的,因此号码管理器的管理对象就只能有一个
    //如果有多个的话,那各个窗口就得分别去不同的管理器的管理对象上查找
    //在目前的情况下,我们假设每个银行都只有一台取号器
    //因此要用到单例设计模式,将NumberMachine的构造函数设计为私有
    private NumberMachine(){}

    //当每个窗口对应的线程创建的时候,都需要获取对应的号码管理器的列表
    //返回对应窗口的号码管理器对象
    public NumberManager getCommonInstance()
    {
        return commonManager ;
    }
    
    public NumberManager getVipInstance()
    {
        return vipManager ;
    }

    public NumberManager getExpressInstance()
    {
        return expressManager ;
    }

    public static NumberMachine getInstance()
    {
        return instance ;
    }
}

5. CustomerType类的分析编写:

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

public enum CostomerType {
	COMMON,EXPRESS,VIP;

 //覆盖toString方法
	public String toString(){
		String name = null;
		switch (this) {
			case COMMON:
				name = "普通"; 	break;
			case EXPRESS:
				name = "快速";	break;
			case VIP:
				name =name();	break;
		}
		return name;
	}
}

6. ServiceWindow类的分析编写:

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

import java.util.concurrent.* ;
import java.util.Random ;

class ServiceWindow 
{
	//每个窗口都有自己的类型,因此要设定一个变量,用来表示当前窗口的类型
	private WindowType windowType = null ;

	//每个窗口都有自己的标号
	private int windowId = 0 ;

	//当前服务的用户
	Integer currentCustomer = 0 ;

	public void setWindowType(WindowType windowType)
	{
		this.windowType = windowType ;
	}

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

	//当窗口建立完以后,就要开始提供服务
	public void start()
	{
		//新建一个线程,每隔一段时间就检查一下号码管理器对象中的号码队列情况
		//如果队列中有客户需要服务,就执行服务代码
		//如果是VIP窗口的话, 在VIP号码队列中没有用户的话,还要检查一下普通用户号码队列
		//如果存在用户需要服务,那VIP窗口也为普通用户服务.
		//同理,快速用户窗口也是这样的
		ScheduledExecutorService es = Executors.newScheduledThreadPool(1) ;
		es.scheduleAtFixedRate(new Runnable()
		{
			public void run()
			{
				while (true)
				{
					if (windowType == WindowType.COMMON)
					{
						commonService() ;
					}
					else if (windowType == WindowType.VIP)
					{
						vipService() ;
					}
					else if (windowType == WindowType.EXPRESS)
					{
						expressService() ;
					}
				}
			}
		}, 
		0, 
		2, 
		TimeUnit.SECONDS) ;
	}

	public void commonService()
	{
		String windowName = "第" + windowId + "号" + windowType ;

		System.out.println(windowName +  "开始获取" + "普通任务!") ;

		if ((currentCustomer =  NumberMachine.getInstance().getCommonInstance().getInstance()) != null)
		{
			System.out.println(windowName + "正在为第" + currentCustomer + "号" + "普通顾客服务") ;

			System.out.println(windowName + "完成为第" + currentCustomer + "号普通任务顾客服务, 耗时" + serviceTime() + "秒") ;

			
		}
		else
		{
			System.out.println(windowName + "没有获取到" + "普通任务!  开始空闲1秒") ;
			try
			{
				Thread.sleep(1000) ;
			}
			catch (Exception e)
			{
				e.printStackTrace() ;
			}
			
		}
	}

	public void vipService()
	{
		String windowName = "第" + windowId + "号" + windowType ;

		System.out.println(windowName +  "开始获取" + "VIP任务!") ;
		
		if ((currentCustomer = NumberMachine.getInstance().getVipInstance().getInstance()) != null)
		{
			System.out.println(windowName + "正在为第" + currentCustomer + "号" + "VIP任务顾客服务") ;

			System.out.println(windowName + "完成为第" + currentCustomer + "号vip任务顾客服务, 耗时" + serviceTime() + "秒") ;
		}
		else
		{
			System.out.println(windowName + "没有获取到" + "VIP任务任务!") ;
			commonService() ;
		}
	}

	public void expressService()
	{
		String windowName = "第" + windowId + "号" + windowType ;

		System.out.println(windowName +  "开始获取快速任务!") ;
		
		if ((currentCustomer = NumberMachine.getInstance().getExpressInstance().getInstance()) != null)
		{
			System.out.println(windowName + "正在为第" + currentCustomer + "号快速任务顾客服务") ;

			System.out.println(windowName + "完成为第" + currentCustomer + "号" + "快速任务顾客服务, 耗时" + serviceTime() + "秒") ;
		}
		else
		{
			System.out.println(windowName + "没有获取到快速任务!") ;
			commonService() ;
		}
	}

	public long serviceTime()
	{
		long beginTime = System.currentTimeMillis() ;

		int timeRange = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME ;

		int costTime = new Random().nextInt(timeRange) + Constants.MIN_SERVICE_TIME ;

		try
		{
			Thread.sleep(costTime) ;
		}
		catch (Exception e)
		{
			e.printStackTrace() ;
		}

		return (System.currentTimeMillis() - beginTime)/1000 ;
	}
}

7. Constants类的分析编写:

定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

//定义的秒数类
public class Constant {
	public static int MAX_SERVICE_TIME = 10000; // 10秒！
	public static int MIN_SERVICE_TIME = 1000; // 1秒！

	/*
	 * 每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
	 * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以， 1秒钟产生一个普通客户比较合理，
	 */
	public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;
}

8. MainClass类的分析编写:

用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。
接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

package cn.itheima.bank ;

import java.util.concurrent.* ;
import java.util.Random ;

class MainClass 
{
	public static void main(String[] args) 
	{
		ServiceWindow window ;

		for (int i = 1; i < 5; i++)
		{
			window = new ServiceWindow() ;

			window.setWindowType(WindowType.COMMON) ;
			window.setWindowId(i) ;

			window.start();
		}

		window = new ServiceWindow() ;
		window.setWindowType(WindowType.VIP) ;
		window.setWindowId(5) ;
		window.start() ;

		window = new ServiceWindow() ;
		window.setWindowType(WindowType.EXPRESS) ;
		window.setWindowId(6) ;
		window.start() ;

		ExecutorService ses = Executors.newSingleThreadExecutor() ;
		ses.execute(new Runnable()
		{
			public void run()
			{
				int type = 0 ;
				int com = 0 ;
				int vip = 0 ;
				int exp = 0 ;

				while (true)
				{
					type = new Random().nextInt(10) ;

					Integer newCustomer = null ;

					if (type < Constants.COMMON_RATE)
					{
						newCustomer = NumberMachine.getInstance().getCommonInstance().addInstance() ;
						System.out.println("第" + newCustomer + "位普通顾客正在等待服务!") ;
						com++ ;
					}
					else if (type < (Constants.COMMON_RATE + Constants.VIP_RATE))
					{
						newCustomer = NumberMachine.getInstance().getVipInstance().addInstance() ;
						System.out.println("第" + newCustomer + "位VIP顾客正在等待服务!") ;
						vip++ ;
					}
					else if (type < (Constants.COMMON_RATE + Constants.VIP_RATE + Constants.EXPRESS_RATE))
					{
						newCustomer = NumberMachine.getInstance().getExpressInstance().addInstance() ;
						System.out.println("第" + newCustomer + "位快速顾客正在等待服务!") ;
						exp++ ;
					}

					try
					{
						Thread.sleep(500) ;
					}
					catch (Exception e)
					{
						e.printStackTrace() ;
					}
				}
			}
		}) ;
	}
}

=============================================

跟着老师的视频敲一遍是挺清晰的, 但是自己写的话一定写不出来.

老师反复说, 能写得这么条例清晰, 是因为贯穿了OOP的思想!!

到现在, 才隐约知道了面向对象的用处, 一直不知道什么用来的.

项目不重要, 重要的是思路. 手法~