黑马程序员-银行业务调度系统(改进版)

原创 2012年03月23日 22:36:38

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


附件为源码,因为只能上传图片格式,我将后缀名改了,如需要查看只需将后缀改为zip或者rar即可。

银行业务调度系统

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

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

Ø 有三种对应类型的客户:VIP客户,普通客户,快速客户(办理如交水电费、电话费之类业务的客户)。

Ø 异步随机生成各种类型的客户,生成各类型用户的概率比例为:

        VIP客户 :普通客户 :快速客户  =  1 3

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

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

Ø 当VIP6号)窗口和快速业务(5号)窗口没有客户等待办理业务的时候,这两个窗口可以处理普通客户的业务,而一旦有对应的客户等待办理业务的时候,则优先处理对应客户的业务。

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

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

面向对象的分析:

银行窗口服务是根据叫号机中是否有人需要服务工作的。即如果有人需要服务,则窗口(或者说负责窗口的人)必须要工作;如果没有需要服务的即可以休息。由于一个银行只有一个叫号器,所以将叫号器用单例模式实现。每一个银行只有一个叫号器,每一个窗口都需要和叫号器有联系(窗口完成任务后询问叫号器是否还有任务)。所以可以在窗口类中设置一个叫号器的成员变量,构造窗口时将那个唯一的叫号器传进去即可。又由于客户分为三类,每一个客户来了之后都会到叫号器上叫一个相应的号码(即普通客户叫普通的号,快速的叫快速号),就相当于叫号器添加一个人(Customer)。由于客户是分类的,所以需要几个线程生成不同的Customer。生成的不同的客户即排队等待的客户,先将客户暂时的“安置”一个等待的地方,即有了缓冲池。将等待人放入到不同的等待序列中。Customer类即是存在的缓冲池,将不同的客户分为不同的类别,又由于他们有共同的特性,所以抽象为Customer类。Customer类提供了添加删除等相应的方法。

如下代码是我根据张老师的思想和我自己的思想相融合得出的结果,运行没有错误,和张老师的源码可能有出入,我没有和张老师的代码对比。

package bank;

public enum CustomerType {

COMMON,EXPRESS,VIP;

@Override

public String toString() {

if(this.name().equals(COMMON.name())){

return "普通";

}

else if(this.name().equals(EXPRESS.name())){

return "快速";

}

else

return "VIP";

}

}

package bank;

import java.util.ArrayList;

import java.util.List;

public class Customer {

private CustomerType customerType = null;

private List<String> customers = new ArrayList<String>();

private int lastNum = 1;

public Customer(CustomerType customerType){

this.customerType = customerType;

}

/*

public synchronized String generateNewCustomer(){

if(customers.size() > 0)

customers.add(customers.size() , String.valueOf(customers.size() + 1));

else

customers.add(String.valueOf(1));

return customers.get(customers.size() - 1);

}*/

public synchronized String generateNewCustomer(){

if(customers.size() > 0)

customers.add(customers.size() , String.valueOf(lastNum++));

else

customers.add(String.valueOf(lastNum++));

return customers.get(customers.size() - 1);

}

public synchronized String generateNewCustomer(CustomerType type){

if(customers.size() > 0)

customers.add(customers.size() , String.valueOf(type.toString() + lastNum++));

else

customers.add(String.valueOf(type.toString() + lastNum++));

return customers.get(customers.size() - 1);

}

public synchronized String remove(){

if(customers.size() > 0)

return customers.remove(0);

else 

return null;

}

public synchronized int getWaitingNum(){

return customers.size();

}

public CustomerType getCustomerType(){

return this.customerType;

}

}

package bank;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ServiceMachine {

private Customer commonCustomer = new Customer(CustomerType.COMMON);

private Customer expressCustomer = new Customer(CustomerType.EXPRESS);

private Customer vipCustomer = new Customer(CustomerType.VIP);

private static ServiceMachine serviceMachine = new ServiceMachine();

private ServiceMachine() {

}

public static ServiceMachine getServiceMachine() {

return serviceMachine;

}

public Customer getCommonCustomer() {

return commonCustomer;

}

public Customer getExpressCustomer() {

return expressCustomer;

}

public Customer getVipCustomer() {

return vipCustomer;

}

public void start() {

this.serviceCommonCustomer();

this.serviceExpressCommonCustomer();

this.serviceVIPCommonCustomer();

}

private void serviceCommonCustomer() {

ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

service.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("进来一个普通客户:"+ ServiceMachine.this.commonCustomer.generateNewCustomer(commonCustomer.getCustomerType()) + "正在等待");

// commonCustomer.generateNewCustomer();

}

}, 0, Util.COMMON_CUSTOMER_RATE, TimeUnit.SECONDS);

}

private void serviceExpressCommonCustomer() {

ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

service.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("进来快速一个客户:"

+ ServiceMachine.this.expressCustomer.generateNewCustomer(expressCustomer.getCustomerType()));

//commonCustomer.generateNewCustomer();

}

}, 0, Util.COMMON_CUSTOMER_RATE * 3, TimeUnit.SECONDS);

}

private void serviceVIPCommonCustomer() {

ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

service.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("进来vip一个客户:"

+ ServiceMachine.this.vipCustomer.generateNewCustomer(vipCustomer.getCustomerType()));

//commonCustomer.generateNewCustomer();

}

}, 0, Util.COMMON_CUSTOMER_RATE * 6, TimeUnit.SECONDS);

}

}

package bank;

import java.util.Random;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CommonServerWindow {

// private ServiceMachine serviceMachine =

// ServiceMachine.getServiceMachine();

private Customer commonCustomer = null;

private int waitingCumtomerNum = 0;

private int windowId = 1;

public CommonServerWindow(ServiceMachine serviceMachine, int windowId) {

// System.out.println("创建窗口" + windowId);

// serviceMachine.start();

commonCustomer = serviceMachine.getCommonCustomer();

this.waitingCumtomerNum = commonCustomer.getWaitingNum();

this.windowId = windowId;

//this.start();

}

public void start() {

ExecutorService service = Executors.newSingleThreadExecutor();

service.execute(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

//CommonServerWindow.this.server();

while(true){

if(CommonServerWindow.this.server(commonCustomer))

continue;

else

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

});

}

/*protected void server() {

while (true) {

if (commonCustomer.getWaitingNum() > 0) {

String customerName = CommonServerWindow.this.commonCustomer.remove();

long currentTime = System.currentTimeMillis();

int serverTime = Util.MAX_SERVER_TIME - Util.MIN_SERVER_TIME;

System.out.println("普通窗口" + CommonServerWindow.this.windowId

+ "正在为 :" + customerName + " 服务");

try {

Thread.sleep((new Random().nextInt(serverTime) + 1) * 2000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("普通窗口 " + CommonServerWindow.this.windowId

+ "为 :" + customerName + "服务耗时-->"

+ (System.currentTimeMillis() - currentTime) / 1000

+ "");

} else {

try {

Thread.sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

protected void server(boolean serverCommon) {

while (serverCommon) {

if (commonCustomer.getWaitingNum() > 0) {

String customerName = CommonServerWindow.this.commonCustomer

.remove();

long currentTime = System.currentTimeMillis();

int serverTime = Util.MAX_SERVER_TIME - Util.MIN_SERVER_TIME;

System.out.println("普通窗口" + CommonServerWindow.this.windowId

+ "正在为 :" + customerName + " 服务");

try {

Thread.sleep((new Random().nextInt(serverTime) + 1) * 2000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("普通窗口 " + CommonServerWindow.this.windowId

+ "为 :" + customerName + "服务耗时-->"

+ (System.currentTimeMillis() - currentTime) / 1000

+ "");

} else {

try {

Thread.sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}*/

protected  boolean server(Customer customer) {

if (customer.getWaitingNum() >= 1) {

String customerName = customer.remove();

//

// if(customerName == null){

// System.out.println(customerName);

// return false;

// }

long currentTime = System.currentTimeMillis();

int serverTime = Util.MAX_SERVER_TIME - Util.MIN_SERVER_TIME;

System.out.println("窗口" + CommonServerWindow.this.windowId

+ "正在为 :" + customer.getCustomerType() + " -- " + customerName + " 服务");

try {

if(customer.getCustomerType() == CustomerType.EXPRESS){

Thread.sleep((new Random().nextInt(Util.MIN_SERVER_TIME) +1) * 1000);

}

else

Thread.sleep((new Random().nextInt(serverTime) + 1) * 3000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("窗口 " + CommonServerWindow.this.windowId

+ "为 :"  + customer.getCustomerType() + " -- " + customerName + "服务耗时-->"

+ (System.currentTimeMillis() - currentTime) / 1000

+ "");

return true;

else

return false;

}

}

package bank;

import java.util.Random;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ExpressServerWindow extends CommonServerWindow {

private Customer commonCustomer = null;

private Customer expressCustomer = null;

private int windowId = 5;

public ExpressServerWindow(ServiceMachine serviceMachine, int windowId) {

super(serviceMachine, windowId);

// TODO Auto-generated constructor stub

commonCustomer = serviceMachine.getCommonCustomer();

expressCustomer = serviceMachine.getExpressCustomer();

this.windowId = windowId;

}

@Override

public void start() {

// TODO Auto-generated method stub

ExecutorService service = Executors.newSingleThreadExecutor();

service.execute(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

ExpressServerWindow.this.server();

}

});

}

protected void server() {

// TODO Auto-generated method stub

boolean serverCommon = false;

while (true) {

if(this.server(expressCustomer))

continue;

else{

if(!this.server(commonCustomer))

continue;

}

/*if (expressCustomer.getWaitingNum() > 0) {

serverCommon = false;

String customerName = "--" + ExpressServerWindow.this.expressCustomer.remove() ;

long currentTime = System.currentTimeMillis();

//int serverTime = Util.MAX_SERVER_TIME - Util.MIN_SERVER_TIME;

System.out.println("快速窗口" + ExpressServerWindow.this.windowId

+ "正在为 :" + customerName + " 服务");

try {

Thread.sleep((new Random().nextInt(Util.MIN_SERVER_TIME) + 1) * 1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("快速窗口 " + ExpressServerWindow.this.windowId

+ "为 :" + customerName + "服务耗时-->"

+ (System.currentTimeMillis() - currentTime) / 1000

+ "");

} else {

serverCommon = true;

}

this.server(serverCommon);

*/

}

}

protected void server(boolean serverCommon) {

if (serverCommon) {

// System.out.println("窗口" + windowId + "开始服务!");

if (commonCustomer.getWaitingNum() > 0) {

//if(expressCustomer.getWaitingNum() > 0) serverCommon = false;

String customerName = ExpressServerWindow.this.commonCustomer.remove();

// if(customerName == null){

// continue;

// }

long currentTime = System.currentTimeMillis();

int serverTime = Util.MAX_SERVER_TIME - Util.MIN_SERVER_TIME;

System.out.println("快速窗口" + ExpressServerWindow.this.windowId

+ "正在为 :" + customerName + " 服务");

try {

Thread.sleep((new Random().nextInt(serverTime) + 1) * 2000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("快速窗口 :" + ExpressServerWindow.this.windowId

+ "为 :" + customerName + "服务耗时-->"

+ (System.currentTimeMillis() - currentTime) / 1000

+ "");

} else {

}

}

}

}

package bank;

import java.util.Random;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class VIPServerWindow extends CommonServerWindow {

private Customer commonCustomer = null;

private Customer vipCustomer = null;

private int windowId = 5;

public VIPServerWindow(ServiceMachine serviceMachine, int windowId) {

super(serviceMachine, windowId);

// TODO Auto-generated constructor stub

this.commonCustomer = serviceMachine.getCommonCustomer();

this.vipCustomer = serviceMachine.getVipCustomer();

this.windowId = windowId;

}

@Override

public void start() {

// TODO Auto-generated method stub

ExecutorService service = Executors.newSingleThreadExecutor();

service.execute(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

VIPServerWindow.this.server();

}

});

}

protected void server() {

// TODO Auto-generated method stub

while (true) {

if(this.server(vipCustomer))

continue;

else{

// if(!this.server(commonCustomer))//如果没有普通客户要服务,continue

// continue;

this.server(commonCustomer);

}

}

}

}

package bank;

public class Test {

public static void main(String[] args) {

ServiceMachine serviceMachine = ServiceMachine.getServiceMachine();

serviceMachine.start();

for(int i = 1; i <= 4; i++){

//System.out.println(i + "----------" + i);

new CommonServerWindow(serviceMachine,i).start();

}

new ExpressServerWindow(serviceMachine,5).start();

new VIPServerWindow(serviceMachine,6).start();

}

}




------------- android培训java培训、期待与您交流! ----------------------详细请查看:http://edu.csdn.net/heima

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

【学习并改进】黑马程序员-张孝祥-银行业务调度系统

import java.util.*; //导入工具包 import java.util.concurrent.*; //导入并发包 /** * 产生多个窗口的叫号系统和模拟不同类型的客户操作。 ...

《黑马程序员》 银行业务调度系统回顾总结

在做银行业务调度系统这个题目的时候,我们是需要了解一下银行业务办理的流程的:    通常情况下是这样的,我们去银行取钱的时候,需要先去取号机器上取号(就相当于我们站在服务窗口前排队一样,只是有了取号机...

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

------- android培训、java培训、期待与您交流! ---------- 个人小心得: 1.       面向对象思维:先不用考虑具体实现,而是应该先对项目进行需求分析,掘出并提...

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

黑马程序与------Android培训------银行业务调度系统

黑马程序员——银行业务调度系统逻辑

---------------------- android培训、java培训、期待与您交流! ----------------------   银行业务调度逻辑,此问题稍微有复杂,需要根据实际情...

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

---------------------- android培训、java培训、期待与您交流! ---------------------- 需求如下: 银行内有6个业务窗口,1- 4号窗口为普通...

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

银行业务调度系统 根据需求我们得到一个关系,银行客服--问-->取号器-->要号-->排队的第一个人--->服务窗口(是不断循环的) 顾客-->取号--->排队--->叫到号--->服务窗口(也是...

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

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流! ----------------------     银行业务调度系统   银行...

黑马程序员 java银行业务调度系统 随笔

----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------      需求: 模拟实现银行业务调度系统逻辑,具体需求如下: 银行业务调度...

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

------- android培训 、java培训 、期待与您交流! ------- 一.业务需求: 模拟实现银行业务调度系统逻辑,具体需求如下: 1. 银行内有6个业务窗口,1- 4号窗...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)