----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------
--------------------------------------------------------交通灯管理系统----------------------------------------------------------------
1.模拟实现银交通灯管理系统逻辑，具体需求如下a.异步随机生成按照各个路线行驶的车辆。
例如：
由南向而来去往北向的车辆 ---- 直行车辆
由西向而来去往南向的车辆 ---- 右转车辆
由东向而来去往南向的车辆 ---- 左转车辆
......
a.信号灯忽略黄灯，只考虑红灯和绿灯。
b.应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。
c.具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。
注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。
d.每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。
e.随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。
f.不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。
2.面向对象的分析与设计
从上图中可以很明确的看出共有12条路线，如图上所示；上图可以分为以下四种情况：
情况一：南北直行车辆：S2N,N2S;
情况二：南北直行车辆通行完毕，南北左转车辆：S2W,N2E;
情况三：南北左转车辆通行完毕后，是东西直行车辆：E2W,W2E;
情况四：东西直行车辆通行完毕，东西左转车辆通行：E2S,W2N。
由上面四种情况可以得出以下几点：
a.设计一个Road类来表示路线，每个Road对象表示一条路线，总共有12条路线，即系统中要产生12个Road实例对象；
每条路线上随机增加新的车辆时，增加到一个集合中保存；当每条线路上有车穿过路口时，则将本路线中保存车的集合中的第一辆车移除。
b.设计一个Lamp类表示一个交通灯，每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。因为共有12条路线，因此系统中总共要产生12个交通灯；其中右转弯的路线不受灯控制，因此该路线上的灯应该是常亮状态，即永远不变黑。除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯。
c.设计一个LampController类，它定时将当前的绿灯变为红灯。
3.代码的实现
a.Road类：
每个Road对象都有一个name成员变量来代表方向，有一个vehicles成员变量来代表方向上的车辆集合。在Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车（用一个“路线名_id”形式的字符串进行表示）。 在Road对象的构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿，是则打印车辆集合和将集合中的第一辆车移除掉。
具体代码实现如下所示：
**
* 每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。 每条路线上随机增加新的车辆，增加到一个集合中保存。
* 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
*/
public class Road {
List<String> vechicles = new ArrayList<String>();
private String name = null;
public Road(String name) {
this.name = name;
// 模拟车辆不断随机上路的过程
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(new Runnable() {
public void run() {
for (int i = 1; i < 1000; i++) {
try {
// 每1到10秒内有辆车上路
Thread.sleep((new Random().nextInt(10) + 1) * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
vechicles.add(Road.this.name + "-" + i);
}
}
});
//每隔一秒检查对应的灯是否为绿，是则放行一辆车
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(new Runnable() {
public void run() {
if (vechicles.size() > 0) {
boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
if (lighted) {
System.out.println(vechicles.remove(0) + " is traversing! ");
}
}
}
}, 1, 1, TimeUnit.SECONDS);
}
} b.Lamp类：
使用枚举类来实现12个方向的灯；增加让Lamp变亮和变黑的方法：light和blackOut，对于S2N、S2W、E2W、E2S这四个方向上的Lamp对象，这两个方法内部要让相反方向的灯随之变亮和变黑，blackOut方法还要让下一个灯变亮。
除了以上四个方向上的Lamp对象之外，其它方向上的Lamp对象的nextLampName和oppositeLampName属性设置为Null即可；
并且S2N、S2W、E2W、E2S这四个方向上的Lamp对象的nextLampName和oppositeLampName属性必须设置为null，以便防止light和blackOut进入死循环。
具体代码实现如下所示：
/**
* 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
* 程序代码只需要控制每组灯中的一个灯即可： s2n,n2s s2w,n2e e2w,w2e e2s,w2n s2e,n2w e2n,w2s
* 上面最后两行的灯是虚拟的，由于从南向东和从西向南、以及它们的对应方向不受红绿灯的控制， 所以，可以假想它们总是绿灯。
*/
public enum Lamp {
/* 每个枚举元素各表示一个方向的控制灯 */
S2N("N2S", "S2W", false), S2W("N2E", "E2W", false), E2W("W2E", "E2S", false), E2S("W2N", "N2S", false),
/* 下面元素表示与上面的元素的相反方向的灯，它们的“相反方向灯”和“下一个灯”应忽略不计！ */
N2S(null, null, false), N2E(null, null, false), W2E(null, null, false), W2N(null, null, false),
/* 由南向东和由西向北等右拐弯的灯不受红绿灯的控制，所以，可以假想它们总是绿灯 */
S2E(null, null, true), E2N(null, null, true), N2W(null, null, true), W2S(null, null, true);
private Lamp() { }
private Lamp(String opposite, String next, boolean lighted) {
this.opposite = opposite;
this.next = next;
this.lighted = lighted;
}
/* 当前灯是否为绿 */
private boolean lighted;
/* 与当前灯同时为绿的对应方向 */
private String opposite;
/* 当前灯变红时下一个变绿的灯 */
private String next;
public boolean isLighted() {
return lighted;
}
/**
* 某个灯变绿时，它对应方向的灯也要变绿
*/
public void light() {
this.lighted = true;
if (opposite != null) {
Lamp.valueOf(opposite).light();
}
System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
}
/**
* 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿
*
* @return 下一个要变绿的灯
*/
public Lamp blackOut() {
this.lighted = false;
if (opposite != null) {
Lamp.valueOf(opposite).blackOut();
}
Lamp nextLamp = null;
if (next != null) {
nextLamp = Lamp.valueOf(next);
System.out.println("绿灯从" + name() + "-------->切换为" + next);
nextLamp.light();
}
return nextLamp;
}
} c.LampController类：
因为整个系统中只有一套交通灯控制系统，所以，LampController类应该设计为单例；在LampController的构造方法中要设定第一个为绿的灯；在调用LampController对象的start方法时将当前灯变绿，然后设置一个定时器，每隔10秒将当前灯变红和将下一个灯变绿。
具体实现代码如下所示：
public class LampController {
// 刚开始让由南向北的灯变绿;
private Lamp currentLamp;
/* 每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿 */
public LampController() {
currentLamp = Lamp.S2N;
currentLamp.light();
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(new Runnable() {
public void run() {
currentLamp = currentLamp.blackOut();
}
}, 10, 10, TimeUnit.SECONDS);
}
} d.MainClass类：
使用for循环创建出代表12条线路的对象；之后实例化LampController对象，并调用其start方法。
具体实现代码如下所示：
//S2N,S2W,E2W,E2S,N2S,N2E,W2E,W2N,S2E,E2N,N2W,W2S
public class MainClass {
public static void main(String[] args) {
/* 产生12个方向的路线 */
String[] directions = new String[] { "S2N", "S2W", "E2W", "E2S", "N2S", "N2E", "W2E", "W2N", "S2E", "E2N", "N2W", "W2S" };
for (int i = 0; i < directions.length; i++) {
new Road(directions[i]);
}
/* 产生整个交通灯系统 */
new LampController();
}
} --------------------------------------------------------银行业务调度系统----------------------------------------------------------------
1、模拟实现银行业务调度系统逻辑，具体需求如下
a.银行内有6个业务窗口，1-4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
b.有三种对应类型的客户：VIP客户，普通客户，快速客户。
c.异步随机生成各种类型的客户，生成各类型用户的概率比例为：VIP客户 ：普通客户 ：快速客户 = 1 ：6 ：3。
d.客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。
e.各类型客户在其对应窗口按顺序依次办理业务。
f.当VIP(6号)窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
g.随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。
h.不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。
a.有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。由于有三类客户，每类客户的号码编排都是完全独立的，因此需要一个产生三个号码管理器对象，各自管理一类用户的排队号码。因此这三个号码管理器对象统一由一个号码机器进行管理，并且号码机器在此系统中始终只能有一个，因此它要设计成单例模式。
b.各类型客户在其对应窗口按顺序依次办理业务，应该是窗口依次叫号。
c.该系统的类图如下所示：
3、代码的实现
a.NumberManager类和NumberMachine类
其中：在NumberManager类中定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合；定义一个产生新号码的方法和获取马上要为之服务号码的方法，这两个方法被不同的线程操作相同的数据，因此，此段代码需要同步实现。具体代码实现如下所示：
public class NumberManager {
private int lastNumber = 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;
}
} b.在NumberMachine类中需要定义三个成员变量分别指向NumberManager对象，分别表示普通、快速和VIP客户的号码管理器并定义三个对应的方法来返回这三个NumberManager对象，此类需要设计成单例；具体代码如下所示
public class NumberMachine{
private NumberManager commonManager = new NumberManager();// 普通用户
private NumberManager expressManager = new NumberManager();// 快速用户
private NumberManager vipManager = new NumberManager();// VIP用户
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();
}c.ServiceWindow类与CustomerType枚举类
其中：CustomerType枚举类：系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户。
具体实现代码如下所示：
//定义枚举表示客户类型
public enum CustomerType{
COMMON, EXPRESS, VIP;
public String toString()
{
String name = null;
switch (this){
case COMMON:
name = "普通";
break;
case EXPRESS:
name = "快速";
break;
case VIP:
name = name();
break;
}
return name;
}
}d.ServiceWindow类：定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用这三个不同的方法；
定义三个方法分别对三种客户进行服务。
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:
vipService();
break;
}
}
}
});
}
/**
* 普通客户服务
* */
private void commonService(){
String windowName = "第" + windowId + "号" + "普通窗口";
Integer number = NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
System.out.println(windowName + "正在获取任务！");
if (number != null){
System.out.println(windowName + "为第" + number + "个普通客户服务");
long beginTime = System.currentTimeMillis();
int maxRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
long serverTime = new Random().nextInt(maxRand) + Constants.MIN_SERVICE_TIME + 1;
try{
Thread.sleep(serverTime);
}
catch (InterruptedException e){
e.printStackTrace();
}
long costTime = System.currentTimeMillis() - beginTime;
System.out.println(windowName + "为第" + number + "个普通客户完成服务，耗时" + (costTime / 1000) + "秒");
}
else{
System.out.println(windowName + "没有取到任务！先休息1秒钟吧！");
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
/**
* 快速客户服务
* */
private void expressService(){
String windowName = "第" + windowId + "号" + type + "窗口";
Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
System.out.println(windowName + "正在获取任务！");
if (number != null){
System.out.println(windowName + "为第" + number + "个" + type + "客户服务");
long beginTime = System.currentTimeMillis();
try{
Thread.sleep(Constants.MIN_SERVICE_TIME);
}catch (InterruptedException e){
e.printStackTrace();
}
long costTime = System.currentTimeMillis() - beginTime;
System.out.println(windowName + "为第" + number + "个" + type + "客户完成服务，耗时" + (costTime / 1000) + "秒");
}else{
System.out.println(windowName + "没有取到任务！");
//当快速窗口没有任务时，需要为普通用户服务
commonService();
}
}
/**
* VIP客户服务
* */
private void vipService(){
String windowName = "第" + windowId + "号" + type + "窗口";
Integer number = NumberMachine.getInstance().getVipManager().fetchServiceNumber();
System.out.println(windowName + "正在获取任务！");
if (number != null){
System.out.println(windowName + "为第" + number + "个" + type + "客户服务");
long beginTime = System.currentTimeMillis();
int maxRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
long serverTime = new Random().nextInt(maxRand) + Constants.MIN_SERVICE_TIME + 1;
try{
Thread.sleep(serverTime);
}
catch (InterruptedException e){
e.printStackTrace();
}
long costTime = System.currentTimeMillis() - beginTime;
System.out.println(windowName + "为第" + number + "个" + type + "客户完成服务，耗时" + (costTime / 1000) + "秒");
}
else{
System.out.println(windowName + "没有取到任务");
//当VIP窗口没有任务时，需要为普通用户服务！
commonService();
}
}
}e.MainClass类与Constants类
其中：MainClass类中：用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口；然后创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码；具体实现代码如下所示：
public class MainClass{
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().getCommonManager().generateNewManager();
System.out.println("第" + number + "号普通客户等待服务！");
}
}, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME, TimeUnit.SECONDS);
// 普通客户拿号
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable(){
public void run(){
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(){
Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();
System.out.println("第" + number + "号快速客户等待服务！");
}
}, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2, TimeUnit.SECONDS);
}
}f.Constants类：定义三个常量MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME，具体实现代码如下所示：
public class Constants{
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;
} ----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------
扫一扫
219
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
