黑马程序员-自己写的银行调度系统

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

自己写的银行调度系统


张老师讲银行调度系统题目及结果演示时，就迫不及待的先开始了自己的实现。

设计要求：
1.模拟客户到来，有三种客户：普通，快速和VIP，比例是6:3:1
2.银行有6个业务窗口：1-4普通，5快速，6 VIP
3.每个客户所需求的时间在最大值和最小值之间，快速用于为最小值
4.客户按顺序办理业务（排队）
5.VIP和快速窗口空闲时（没人排队）可以为普通用户服务


一、准备工作
1.需要7个线程，1个用于模拟客户的到来（GenerateClientThread）；其他6个模拟6个服务窗口（WindowThread）
2.需要3个队列，分别用于普通用户，快速用户，VIP用户排队。GenerateClientThread负责随机生成用户并放入队列。WindowThread负责从相应的队列中取用户，并为他服务。
3.每个客户Client有这些属性：业务类型type（普通，快速还是VIP），在该业务类型中的排队编号number，，需要时间（在最大值最小值内随机生成，快速用户为最小值）serverTime。以及相应的get，set方法。
4.怎么实现队列？暂时还没搞懂Java中队列怎么实现，这里就先用ArrayList替代。队列中存放Client对象，所以定义为ArrayList<Client>类型。自己编写进队（inQ）和出队（outQ）方法。
共有三个队列，每个队列都是单例模式。
5.怎么模拟产生客户。建立一个客户产生器（ClientGenerator）类，因为只能有一个产生器，所以定义为单例模式。提供generateClient方法按照比例产生Client对象并初始化随机生成的服务时间。GenerateClientThread线程每隔一段时间生成一个客户，并加入到相应的队列中去。WindowThread线程每隔一段时间从相应的队列中取出用户，特别注意，取用户操作一定要加同步锁，防止多个窗口同时取一个队列导致的错误。


二、主函数
用于程序的入口，里面实现了7个线程的定义和启动。即：1个模拟客户生成的线程（GenerateClientThread）和6个服务窗口线程（WindowThread）。因为他们是独立工作的，所以使用线程独立运行。
public static void main(String[] args)
{
GenerateClientThread thread0 = new GenerateClientThread();
WindowThread1 wt1 = new WindowThread1();
WindowThread2 wt2 = new WindowThread2();
WindowThread3 wt3 = new WindowThread3();
WindowThread4 wt4 = new WindowThread4();
WindowThread5 wt5 = new WindowThread5();
WindowThread6 wt6 = new WindowThread6();
thread0.start();
wt1.start();
wt2.start();
wt3.start();
wt4.start();
wt5.start();
wt6.start();
}
（省略线程的定义）


三、服务窗口的定义


//服务窗口的抽象类，维护窗口类型和窗口编号两个属性，提供服务方法
public abstract class ServerWindow
{
private int WindowNumber;
private int WindowType;
public int getWindowNumber()
{
return WindowNumber;
}
public int getWindowType()
{
return WindowType;
}

public String getWindowTypeName()
{
String typeName = null;
switch(this.getWindowType())
{
case Client.COMMON: 
typeName = "普通 ";
break;
case Client.FAST:
typeName = "快速 ";
break;
case Client.VIP:
typeName = "VIP ";
break;
default: break;
}
return typeName;
}
public ServerWindow(int number, int type)
{
this.WindowNumber = number;
this.WindowType = type;
}
//每种窗口获取相应的客户的方法是不同的（队列不同），所以定义为抽象方法，等继承的实现类来完成。
public abstract Client fech();
//获取普通队列中的客户，这个方法是公用且已知的。
protected synchronized Client fechCom()
{
BankQueue queue = CommonQueue.getInstance();
Client client = queue.outQ();
return client;
}
//启动服务的入口
public Client serve()
{
//从自己的队列中获取用户
Client client = fech();
if(client != null)
{
serveFor(client);//为这个客户服务
}
//如果自己的队列中没有用户排队，则为普通用户服务（非普通窗口干的事）
else if(this.getWindowType() != Client.COMMON)
{
client = fechCom();
if(client != null)
serveFor(client);
}
return client;
}
private void serveFor(Client client)
{
System.out.println("服务: "+this.WindowNumber+"号 ["+this.getWindowTypeName()+"] 窗口开始为"+"第"+client.getNumber()+"号"+client.getTypeName()+"服务");
}

}


class CommonServerWindow extends ServerWindow
{
public CommonServerWindow(int number, int type)
{
super(number, type);
// TODO Auto-generated constructor stub
}
@Override
public synchronized Client fech()
{//fech这个方法一定要加上synchronized修饰符，防止多线程同时访问。
return fechCom();
}
}


class FastServerWindow extends ServerWindow
{


public FastServerWindow(int number, int type)
{
super(number, type);
// TODO Auto-generated constructor stub
}


@Override
public synchronized Client fech()
{
BankQueue queue = FastQueue.getInstance();
Client client = queue.outQ();
return client;
}

}


class VIPServerWindow extends ServerWindow
{


public VIPServerWindow(int number, int type)
{
super(number, type);
// TODO Auto-generated constructor stub
}


@Override
public synchronized Client fech()
{
BankQueue queue = VIPQueue.getInstance();
Client client = queue.outQ();
return client;
}

}


四、客户产生器

public class ClientGenerator
{//客户产生器，专门用于模拟客户的到来，模拟客户（普通，快速，VIP，6:3:1）
private static ClientGenerator generator = new ClientGenerator();
private static long commonNumberBase = 1;
private static long fastNumberBase = 1;
private static long VIPNumberBase = 1;
private ClientGenerator()
{
}
public static ClientGenerator getInstance()
{
return generator;
}
public Client generateClient()
{
Client client = new Client();
double num = Math.random();
double time = Math.random();
int number = (int)(num * 100);
if(number < 10)
{
client.setType(Client.VIP);
client.setNumber(VIPNumberBase);
time = time * 7000 + 500;
client.setServerTime((long)time);
VIPNumberBase++;
}
else if(number < 40)
{
client.setType(Client.FAST);
client.setNumber(fastNumberBase);
client.setServerTime(500);
fastNumberBase++;
}
else 
{
client.setType(Client.COMMON);
client.setNumber(commonNumberBase);
time = time * 7000 + 500;
client.setServerTime((long)time);
commonNumberBase++;
}

return client;
}
}


五、客户类的定义
package com.snow;
class Client
{
public static final int COMMON = 0;
public static final int FAST = 1;
public static final int VIP = 2;
private int type;
private long number;
private long serverTime;
public int getType()
{
return type;
}

public String getTypeName()
{
String typeName = null;
switch(this.getType())
{
case COMMON: 
typeName = "普通用户";
break;
case FAST:
typeName = "快速用户";
break;
case VIP:
typeName = "VIP用户";
break;
default: break;
}
return typeName;
}


public void setType(int type)
{
this.type = type;
}


public long getNumber()
{
return number;
}
public void setNumber(long number)
{
this.number = number;
}
public void setServerTime(long serverTime)
{
this.serverTime = serverTime;
}
public long getServerTime()
{
return serverTime;
}
@Override
public String toString()
{
return "Client [number=" + number + ", type=" + this.getTypeName() + "]";
}
}

六、队列的定义

abstract class BankQueue
{


public void inQ(Client client)
{
this.getList().add(client);
}
public synchronized Client  outQ()
{
Client client = null;
List<Client> list = this.getList();
if(!list.isEmpty())
client = list.remove(0);
return client;
}
public abstract int getLength();
public abstract List<Client> getList();
}


class CommonQueue extends BankQueue
{
private static List<Client> list = new ArrayList<Client>();
private static CommonQueue queue = new CommonQueue();
private CommonQueue()
{
}
public static BankQueue getInstance()
{
return queue;
}

@Override
public int getLength()
{
// TODO Auto-generated method stub
return list.size();
}
@Override
public List<Client> getList()
{
// TODO Auto-generated method stub
return list;
}
}


class FastQueue extends BankQueue
{
private static List<Client> list = new ArrayList<Client>();
private static FastQueue queue = new FastQueue();
private FastQueue()
{
}
public static BankQueue getInstance()
{
return queue;
}

@Override
public int getLength()
{
// TODO Auto-generated method stub
return list.size();
}
@Override
public List<Client> getList()
{
// TODO Auto-generated method stub
return list;
}
}
class VIPQueue extends BankQueue
{
private static List<Client> list = new ArrayList<Client>();
private static VIPQueue queue = new VIPQueue();
private VIPQueue()
{
}
public static BankQueue getInstance()
{
return queue;
}

@Override
public int getLength()
{
// TODO Auto-generated method stub
return list.size();
}
@Override
public List<Client> getList()
{
// TODO Auto-generated method stub
return list;
}


}

不多说，继续看视频，看看老师是怎么实现的。

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