7K面试题,银行业务

最新推荐文章于 2021-02-28 03:30:49 发布
火鱼
最新推荐文章于 2021-02-28 03:30:49 发布
阅读量513
点赞数
分类专栏： java基础日记
本文链接：https://blog.csdn.net/luck28/article/details/8631665
版权
java基础日记专栏收录该内容
30 篇文章 0 订阅
订阅专栏
/*
需求：
面向对象的分析与设计：
	取号机器：产生客户.每个客户都有号码，四个普通窗口的号码都共用一个号码计数器。
	所以得定义一个:
	号码计数器。共用一个数据增删，得加锁。
	各个窗口叫号， 窗口问取号机器。机器每次都得判断是哪个窗口叫号，先为这种类型的用户服务，
	没有再为普通用户服务。每个服务都得开辟一个线程。

	服务窗口。窗口有自己的用户类型，还有窗口编号。创建用户窗口前，我们先判断为哪种用户服务，再创建对应的
	窗口。窗口服务是不间断的，要用到while循环，我上面已经定义了窗口类型，所以可以用选择用户服务外面。

	
	用户产生，普通用户：快速用户：VIP=6：3：1
	用户是不间断按照比例产生的，我们可以用定时炸弹器，设好间隔时间，就可以产生带比例的用户类型。

*/
import java.util.ArrayList;
import java.util.List;

public class NumberManager {

	private int lastNumber = 1;//第一个用户为1.
	private List<Integer> queueNumber = new ArrayList<Integer>();//每份数据带一个容器
	public synchronized Integer generateNewManager(){
		queueNumber.add(lastNumber);//调用一次，增加一个用户数
		return lastNumber++;
	}
		
	public synchronized Integer fetchServiceNumber(){//操作同一份数据，得带锁
		Integer number = null;
		if(queueNumber.size()>0){//有用户，才服务啊
			number =  queueNumber.remove(0);//为最前面的一个服务
		}		
		return number;
	}
	

}

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;
	}
	//单例，只有一个机器产生各种号码。
	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;//枚举设置窗口类型
	public void setType(CustomerType type) {
		this.type = type;//类型有初始值为普通窗口，那我们要设置其他类型的窗口
	}

	private int windowId = 1;//每几号服务窗口，普通窗口有4个。
	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:
									vipService();
									break;
								
							}
							
						}
						
					}

					private void commonService() {//普通服务
						String windowName = "第"+windowId+"号"+type+"窗口";
						
						//向机器人要普通用户的号码。如果有，就开始服务
						Integer number = NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
						System.out.println(windowName+"正在获取任务");
						if(number!=null){
							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 {
								System.out.println(windowName+"为第"+number+"个"+"普通"+"服务中");
								Thread.sleep(serveTime);
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
							long endTime = System.currentTimeMillis();
							System.out.println(windowName+"为第"+number+"个"+"普通"+"完成服务,用时"
							+(endTime-beginTime)/1000+"秒");
						}
						else{
							System.out.println(windowName+"没有取到服务,休息1秒");
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}
					}
					
					private void expressService() {
						String windowName = "第"+windowId+"号"+type+"窗口";
						Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
						System.out.println(windowName+"正在获取任务");
						if(number!=null){
							long beginTime = System.currentTimeMillis();
							
							//long maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
							//long serveTime = new Random().nextInt(9000)+1+Constants.MIN_SERVICE_TIME;
							try {
								Thread.sleep(Constants.MIN_SERVICE_TIME);
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
							long endTime = System.currentTimeMillis();
							System.out.println(windowName+"为第"+number+"个"+type+"完成服务,用时"
									+(endTime-beginTime)/1000+"秒");
						}
						else{
							System.out.println(windowName+"没有取到服务");
							commonService();//没用快速用户，就为普通用户服务
						}
					}
					
					private void vipService() {
							String windowName = "第"+windowId+"号"+type+"窗口";
							Integer number = NumberMachine.getInstance().getVipManager().fetchServiceNumber();
							System.out.println(windowName+"正在获取任务");
							if(number!=null){
							long beginTime = System.currentTimeMillis();
							
							//long maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
							//long serveTime = new Random().nextInt(9000)+1+Constants.MIN_SERVICE_TIME;
							try {
								Thread.sleep(Constants.MIN_SERVICE_TIME);
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
							long endTime = System.currentTimeMillis();
							System.out.println(windowName+"为第"+number+"个"+type+"完成服务,用时"
							+(endTime-beginTime)/1000+"秒");
						}
						else{
							System.out.println(windowName+"没有取到服务");
							commonService();
						}
					}
				});
		}
}

public enum CustomerType {//窗口的类型枚举
	COMMON,EXPRESS,VIP;
	
	public String toString(){//为了显示中文。
		switch(this){
		case COMMON:
			return "普通";
		
		case EXPRESS:
			return "快速";
		
		case VIP:
			return name();
		}
		return null;
	}
}

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 {
	public static void main(String[] args){
		 
		for(int i= 1;i<5;i++){
			ServiceWindow commonWindow = new ServiceWindow();
			commonWindow.setWindowId(i);//产生四个不同的普通窗口
			commonWindow.start();//开启线程，start()方法里有线程
		}		
	
			ServiceWindow vipWindow = new ServiceWindow();
			vipWindow.setType(CustomerType.VIP);//设置快速窗口属性
			vipWindow.start();//启动VIP服务
			
			ServiceWindow expressWindow = new ServiceWindow();
			expressWindow.setType(CustomerType.EXPRESS);
			expressWindow.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);
			
			Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
					new Runnable(){

						public void run() {
							// TODO Auto-generated method stub
							Integer number = NumberMachine.getInstance().getVipManager().generateNewManager();
							System.out.println(number+"号vip客户进来了等待服务");
						}
						
					}, 
					0, 
					Constants.COMMON_CUSTOMER_INTERVAL_TIME*6, 
					TimeUnit.SECONDS);
			
			Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
					new Runnable(){

						public void run() {
							// TODO Auto-generated method stub
							Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();
							System.out.println(number+"号快速客户进来了等待服务");
						}
						
					}, 
					0, 
					Constants.COMMON_CUSTOMER_INTERVAL_TIME*2, 
					TimeUnit.SECONDS);
	
	}

}