JavaSE——Java交通系统

交通系统仿真

摘要:

本文首先对张孝祥老师交通灯系统的面试题,根据自己的理解进行了解析,并给出了自己编写的代码. 之后, 本文根据视频中张老师的解析, 比较了自己的解法和张老师解法的不同, 总结了优劣. 最后给出了总结.  

I. 需求: 

1. 模拟车辆过过十字路口, 车辆随机驶入路口, 判断红绿灯是否可以通行, 不考虑黄灯

2. 先放一对方向(如North-South)直行,再左转, 之后放行另一对方向直行,再左转

3. 右转不受限

4. 车辆过街要1s

II. 思考过程:
(此处为自己编写的思路,与张老师视频中的思路略有不同)

1. 红绿灯种类有限, 而且次序变化是固定的, 考虑将灯的变化定义成一个枚举类SignalEnum

2. 需要有一个控制中心去控制灯的变化, 定义一个类ControlCenter

3. 车辆随机驶入路口, 而车辆在此时就有了明确的行驶和转向, 这个类型可以和SignalEnum里面定义的类型匹配

——————————————————————————————————————————————————

1.1 考虑对面方向灯变化的一致性, 右转无需设定, 枚举一共有4种变化类型: NORTHSOUTH_STR, NORTHSOUTH_LEFT, EASTWEST_STR, EASTWEST_LEFT

1.2 考虑灯有红,绿两种情况, 用一个boolean green; 来记录红绿, green=true为绿, green=false为红

1.3 需要将green设置为private并提供isGreen()/ setGreen()两个方法判断/设置灯的红绿

1.4 为方便可读性, 定义setRed()函数, 于setGreen()操作相反

1.5 考虑灯的变绿顺序变化, 在枚举类中定义 abstract nextGreenSignal() 函数, 返回下一个变绿的枚举类

1.6 模拟1s中过道, 程序等1s; await(1s)

——————————————————————————————————————————————————

2.1 控制中心需要调用枚举类中的枚举元素,并通过isGreen/setGreen/setRed对SignalEnum元素的灯红绿变化控制

2.2 控制中心内提供greenDuration(); 方法, 控制路灯的时间

2.3 控制中心需要按顺序循环实现对SignalEnum元素红绿灯控制

2.4 因为每辆车要1s中的时间过街, currentGreenSignal 变红后要等1s再让下一个灯变绿

2.5 可将ControlCenter作为单独的线程存在

——————————————————————————————————————————————————

3.1 车辆随机驶入路口, 可以看做是一个线程进入程序运行

3.2 因为, 车辆需要根据自己的行驶判断相应SignalEnum元素红绿灯, 不放直接将 SignalEnum implements Runnable, 将SignalEnum.Xxxx传入线程, 让线程判断SignalEnum中的green

3.3 控制台也对SignalEnum中元素的green成员进行操作,所以加同步可以保证多线程对公共资源操作的数据安全

3.4 来一个路口的车可能很多, 所以会有多个一类的线程同时存在, 需要定义一个condition让他们红灯await, 当控制台端变绿时, 控制台端 signalAll

3.5 由于有四个方向, 更好的是将Lock,Condition和SignalEnum中的枚举类一一绑定, 这样, 控制台没换到一个currentGreenSignal时,就同步到等一类灯变绿的线程车上,去唤醒这一类的线程

3.6 考虑右转, 在枚举类型里添加一个 NSEW_RIGHT标记所有右转的车辆的Runnable操作对象, 此对象内部复写isGreen;setRed

3.7 传入线程的SignalEnum在线程中不支持, 建立CarThread extends Thread, 创建一个新的构造函数

III 代码:

1. SignalEnum枚举类定义交通灯的种类及功能

package cn.itcast.trafficSystemSimulation;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;

/*
* 1. 用枚举定义不同的信号灯情况, 分为 NORTHSOUT_STR,NORTHSOUTH_LEFT,EASTWEST_STR,
*    EASTWEST_LEFT,(NSEW_RIGHT）
* 2. 需要将信号等的情况传给CarThread作为线程的Runnable的对象使用,实现Runnable    --> 3.2
* 3. NSEW_RIGHT这两种情况只是为了给Car传入用时,考虑车辆右行总是无需停车的状况准备的 --> 3.6
*    对控制台控制红绿灯的方面没有用的
*/
public enum SignalEnum implements Runnable{ // --> 3.2
// 枚举列表开始 |---      --> 1.1
NORTHSOUTH_STR{
public SignalEnum nextGreenSignal(){
return NORTHSOUTH_LEFT;
}
},
NORTHSOUTH_LEFT{
public SignalEnum nextGreenSignal(){
return EASTWEST_STR;
}
},
EASTWEST_STR{
public SignalEnum nextGreenSignal(){
return EASTWEST_LEFT;
}
},
EASTWEST_LEFT{
public SignalEnum nextGreenSignal(){
return NORTHSOUTH_STR;
}
},

NSEW_RIGHT{ 					// --> 3.6
public SignalEnum nextGreenSignal(){
return NSEW_RIGHT;
}
public boolean isGreen(){return true;}
public void setRed(){};
};
// 枚举列表结束 ---|
// ---------------------- 控制台部分需要设置红绿灯部分方法 ----------------------------- //
private boolean green=false; 		        // --> 1.2
public boolean isGreen(){return green;} 	// --> 1.3
public void setGreen(){green=true;} 		// --> 1.3
public void setRed(){green=false;}  		// --> 1.4
public abstract SignalEnum nextGreenSignal(); 	// --> 1.5
// --------------------- Runnable 接口部分复写内容 ---------------------------------- //
/*
* 复写run,调用checkSignal方法
*/
public void run(){
try{
checkSignal();
}catch(InterruptedException e){
e.printStackTrace();
}
}
private Lock lock=new ReentrantLock(); 		     // --> 3.5
private Condition stopCondition=lock.newCondition(); // --> 3.5
/*
* checkSignal用来件事 green的值,如果false,await;
* 此处同步ControlCenter内部分代码,如果green=true, await线程唤醒,且可以出循环继续执行
*/
public void checkSignal() throws InterruptedException{
lock.lock(); 	// --> 3.3
try{
while(!isGreen()){
System.out.println(this+"'s "
+Thread.currentThread().getName()+" wait for red."
+" Green?"+isGreen());
stopCondition.await();		// --> 3.4
System.out.println(this+"'s "
+Thread.currentThread().getName()+" notified for green."
+" Green?"+isGreen());
}
stopCondition.await(1000,TimeUnit.MILLISECONDS); // --> 1.6
System.out.println(this+"'s "
+Thread.currentThread().getName()+ " acrossed");
}finally{lock.unlock();} // --> 3.3
}
/*
* getCondition返回一个对应枚举元素的Lock
*/
public Lock getLock(){
return lock;
}
/*
* getCondition返回一个对应枚举元素Lock的Condition
*/
public Condition getCondition(){
return stopCondition;
}
}

2. ControlCenter实现对枚举类SignalEnum的操作

package cn.itcast.trafficSystemSimulation;
import java.util.concurrent.locks.Lock;
/*
* ControlCenter实现对枚举类SignalEnum的操作
*  - 实现红绿灯设置
*  - 实现灯按顺序循环
*  - 实现对CarThread的唤醒
*/
public class ControlCenter implements Runnable{	// --> 2.6
public void greenDuration(){		// --> 2.2
try {
Thread.sleep(5000 );
}catch (InterruptedException e){
e.printStackTrace();
}
}

public void run(){
SignalEnum currentGreenSignal=SignalEnum.NORTHSOUTH_STR;
while(true){
Lock lock=currentGreenSignal.getLock();
lock.lock();
try{
currentGreenSignal.setGreen();                  // --> 2.1
System.out.println("-------Signal-------"
+currentGreenSignal+" is green!");
currentGreenSignal.getCondition().signalAll(); // --> 3.4
}finally{
lock.unlock();
}
this.greenDuration();                          // --> 2.2
currentGreenSignal.setRed();                   // --> 2.1
System.out.println("--------Signal-------"
+currentGreenSignal+" is red!"+"  STOP!");
try {
Thread.sleep(1000);                   // --> 2.4
} catch (InterruptedException e) {
e.printStackTrace();
}
currentGreenSignal=currentGreenSignal.nextGreenSignal();
// --> 2.4
}
}
}

3. CarThread模拟车过路口

package cn.itcast.trafficSystemSimulation;
/*
* CarThread方法继承Thread
*  - 需传入一个Enum类型，要重建构造函数
*/
public class CarThread extends Thread {   // --> 3.7
public CarThread(SignalEnum target,String name){ // --> 3.7
super(target,name);
System.out.println(this+" comes here.");
}
public String toString(){
return "Car:"+getName();
}
}

IV 演示:

package cn.itcast.trafficSystemSimulation;
/*
* TrafficSystemSimulation演示结果 Car 0-5 对应 CarThread0-5
* Car 0-5 从不同方向同时来到路口
*/
public class TrafficSystemSimulation {
public static void main(String[] args) {
ControlCenter ctrlCenter=new ControlCenter();
Thread ctrlThread=new Thread(ctrlCenter);
CarThread CarThread0=new CarThread(SignalEnum.EASTWEST_STR,"Car 0");
CarThread CarThread1=new CarThread(SignalEnum.NORTHSOUTH_LEFT,"Car 1");
CarThread CarThread2=new CarThread(SignalEnum.EASTWEST_STR,"Car 2");
CarThread CarThread3=new CarThread(SignalEnum.EASTWEST_LEFT,"Car 3");
CarThread CarThread4=new CarThread(SignalEnum.EASTWEST_STR,"Car 4");
CarThread CarThread5=new CarThread(SignalEnum.NSEW_RIGHT,"Car 5");
ctrlThread.start();
CarThread0.start();
CarThread1.start();
CarThread2.start();
CarThread3.start();
CarThread4.start();
CarThread5.start();
}
}

输出结果:
Car:Car 0 comes here.
Car:Car 1 comes here.
Car:Car 2 comes here.
Car:Car 3 comes here.
Car:Car 4 comes here.
Car:Car 5 comes here.
-------Signal-------NORTHSOUTH_STR is green!
EASTWEST_STR's Car 0 wait for red. Green?false
EASTWEST_STR's Car 2 wait for red. Green?false
NORTHSOUTH_LEFT's Car 1 wait for red. Green?false
EASTWEST_LEFT's Car 3 wait for red. Green?false
EASTWEST_STR's Car 4 wait for red. Green?false
NSEW_RIGHT's Car 5 acrossed
--------Signal-------NORTHSOUTH_STR is red!  STOP!
-------Signal-------NORTHSOUTH_LEFT is green!
NORTHSOUTH_LEFT's Car 1 notified for green. Green?true
NORTHSOUTH_LEFT's Car 1 acrossed
--------Signal-------NORTHSOUTH_LEFT is red!  STOP!
-------Signal-------EASTWEST_STR is green!
EASTWEST_STR's Car 0 notified for green. Green?true
EASTWEST_STR's Car 2 notified for green. Green?true
EASTWEST_STR's Car 4 notified for green. Green?true
EASTWEST_STR's Car 4 acrossed
EASTWEST_STR's Car 0 acrossed
EASTWEST_STR's Car 2 acrossed
--------Signal-------EASTWEST_STR is red!  STOP!
-------Signal-------EASTWEST_LEFT is green!
EASTWEST_LEFT's Car 3 notified for green. Green?true
EASTWEST_LEFT's Car 3 acrossed
--------Signal-------EASTWEST_LEFT is red!  STOP!
-------Signal-------NORTHSOUTH_STR is green!
--------Signal-------NORTHSOUTH_STR is red!  STOP!
-------Signal-------NORTHSOUTH_LEFT is green!
--------Signal-------NORTHSOUTH_LEFT is red!  STOP!
-------Signal-------EASTWEST_STR is green!
--------Signal-------EASTWEST_STR is red!  STOP!

V. 与张老师代码比较

1. 张老师思路:

a. 把每个路口的车等待和放行动作用集合Road的存和取完成, 实现FIFO(这一点比我的程序考虑的更好一点)

a.1 这个集合包含两个线程, 1个线程负责阻车,一个线程负责把放车(此处用到JDK1.5新的线程方法)

a.2 阻车线程是通过随机间隔时间向集合添加元素的方式实现的, 放车是通过线程以一定的频率监测红绿灯来实现的

b. 也用了一个枚举Lamp来表示灯的种类(不过,这里面张老师的枚举把所有的都举出以opposite去关联对面的车)

c. 也用了一个控制台LampController来控制灯的变化,这里用了一个Executor去以固定的频率转换绿的灯

2. 本质的区别:

a. 我的程序的思路是让等的变化去唤醒车辆线程, 张老师的程序是让没个Road的放车线程去每隔1s监测红绿灯的变化

b. 张老师的程序用了一个集合的思想表现出车排队, 最多有2倍的Road的种类(12)的线程(24),可以FIFO, 而我的程序没有做到这一点, 而是让每一个车作为一个线程,来多少个车就新开多少个线程,  当然这些线程多数处于等待状态, 唤醒时无法控制唤醒状态(相比较,张老师集合的思路更好, 一个推广是可以做双车道的优化)

 VI. 总结

1. 程序还可以根据集合的思想进行优化

2. JDK1.5多线程的部分需要学习

3. 枚举类内的可读性和等转换的运用还是比较满意的