经典面试项目--交通灯管理系统

项目由来：

该项目原本是软通动力的一道面试题，交由面试者带回去自行完成，审核通过后即通过面试，当然现在不可能再作为面试题了。不过这个项目还是非常有实践意义的，在网络上传播广泛，从中我们可以学习面向对象的程序设计精髓，对于掌握Java SE基础的初学者而言意义更甚。好了，下面就具体看一看这个项目。

异步随机生成按照各个路线行驶的车辆。

例如：

       由南向而来去往北向的车辆 ---- 直行车辆

       由西向而来去往南向的车辆 ---- 右转车辆

       由东向而来去往南向的车辆 ---- 左转车辆

       。。。

信号灯忽略黄灯，只考虑红灯和绿灯。

应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。

具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。

注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆

每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。

随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

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

思路分析与程序设计

从项目需求中可以发现主要有交通灯、各个路线的行驶车辆两大类。

路线分析以及时间设定：结合现实情况分析可知一个方向向其他三个方法各有一条路线，既然是十字路口那么线路总共是3x4=12条。

 

红绿灯规则：右转信号灯常绿，每辆车通过路口的时间为1秒钟，并且后面有紧随其后开来的车，这里我们设定随机生成一个车辆的时间为2-10秒钟，设定每个路口直行绿灯亮20秒，左转绿灯亮15秒，于是可以得到直行红灯时间为50秒，左转红灯时间为55秒。示意图如下：

 

比如从南向北以及对向直行绿灯时间到了转为红灯，那么同一时间从南向西以及对向左转红灯时间到转为绿灯，绿灯时间到转为红灯之后，在同一个时间从西向东以及对向直行红灯时间到转为绿灯，绿灯时间到转为红灯…如此往复循环。所以红绿灯需要一个控制器来控制，我们在编程时就单独用一个类来实现这个控制器。由于一个线路上的灯与其对向线路的灯规则完全一致，并且右转绿灯常亮。根据这一现象，我们只需要控制四个方向的灯即可。

综合上面的分析，我们可以大致明白要实现哪些类了，分别为：

1，Road类，代表行驶路线的类，由于这里每条线路都会随机生成一些车辆，所以我们就不需要单独列出一个表示车辆的类了，直接作为路线类的成员变量即可。

2，Lamp类，表示每条线路上的红绿灯的类，由于这里只有固定的12条线路，不能再单独列出一个线路，所以使用枚举定义该类最为合适。

3，LampController类，控制Lamp对象。

4，一个运行程序的主类。

下面就对各个类进行具体分析需要实现哪些功能吧。

 

Road类，

1， 每条线路要有表示自己的名称的属性，自然选择String。

2， 每条线程需要一个可以添加、删除（分别对应车辆开到路口、通过路口之后开走）的表表示该线路上的车辆，自然选择ArrayList。

3， 每隔2-10秒钟开来一辆车，需要一个单独的线程通过定时器实现。开来一辆车则装入ArrayList列表中，开走一辆车则从列表中删除。车辆使用线路名_ID标识。

4， 检查对应灯的状态，若为绿灯则每一秒钟开走一辆车，从ArrayList列表中删除，同样需要建立一个单独的线程。

 <span style="font-size:14px">import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;


 public class Road {
     // 表示车辆的集合
     private List<String> vechicles = new ArrayList<String>();
     // 路线名
     private String name =null;

     public Road(String name){
         this.name = name;

         //在构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿，
         //是则打印车辆集合和将集合中的第一辆车移除掉。
         //创建线程池，使用单个worker线程的Executor，以无界队列方式来运行该线程。
         ExecutorService pool = Executors.newSingleThreadExecutor();

         //新建一个Runnable的实现类的对象，在未来某个时间执行给定的命令。
         pool.execute(new Runnable() {
             public void run(){
                 int id = 1;
                 while(true) {
                     //每隔2-10秒钟驶来一辆车，利用线程休眠实现，新来的车添加进集合末尾，表示后来
                     try {
                         Thread.sleep((new Random().nextInt(9) + 2) * 1000);
                     } catch(InterruptedException e) {
                         e.printStackTrace();
                     }
                     vechicles.add(Road.this.name + "_" + id++);
                 }
             }
         });

         //每隔一秒钟检查路上的灯是否为绿灯，若是，则通过一辆最前面的车，将车从集合中删除
         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) + " 驶过路口！");
                         }
                     }
                 }
             },                  //要执行的任务
             1,                  //首次执行的延迟时间
             1,                  //两次操作之间的时间差
             TimeUnit.SECONDS    //设定时间的单位为秒
         );
     }
 }</span>

 

Lamp类，

1，固定十二条线路所以有对应的十二个Lamp实例，上面分析得到只需要控制其中的四条线路即可。

2，每个灯都有状态显示，绿（true）和红（false），并且一条线路上的灯变红或者变绿之后其对向线路上的灯要与之同步，下一条线路上的灯也要随之作出反应变为绿灯。

3，由于直行和左转绿灯时间不同，所以还需要引入方向（Direction）接口并增加一个属性direction表示灯所在路线的方向

 <span style="font-size:14px">public interface Direction {
     /*表示路线的行驶方法，有三个值，如下*/
     public static final int LEFT = -1;
     public static final int CENTER = 0;
     public static final int RIGHT = 1;

     int getDirection();
 }</span>

 <span style="font-size:14px">import java.util.Date;

 enum Lamp implements Direction {
     //每个枚举元素各表示一个方向的控制灯
     S2N("N2S", "S2W", CENTER, false), S2W("N2E", "E2W", LEFT, false), E2W("W2E", "E2S", CENTER, false), E2S("W2N", "S2N", LEFT, false),

     // 与上面声明的四个方向的灯一一对应，被动执行即可
     N2S(null, null, CENTER, false), N2E(null, null, LEFT, false), W2E(null, null, CENTER, false), W2N(null, null, LEFT, false),

     // 右转信号灯常亮为绿灯
     S2E(null, null, RIGHT, true), E2N(null, null, RIGHT, true), N2W(null, null, RIGHT, true), W2S(null, null, RIGHT, true);

     private String opposite;    //表示对向路线的灯
     private String next;        //表示下一条路线的灯
     private boolean lighted;    //灯的状态
     private int direction;      //表示灯所在路线的方向，可能为LEFT\CENTER\RIGHT


     private Lamp(String opposite, String next,int direction, boolean lighted){
         this.opposite = opposite;
         this.next = next;
         this.direction = direction;
         this.lighted = lighted;
     }

     public boolean isLighted(){
         return lighted;         //判断灯的状态，变亮表示绿灯，变黑表示红灯
     }

     public int getDirection() {     //获取灯所在路线的方向
         return direction;
     }

     // 将当前灯变为绿灯，同时其对向的灯一起随之改变
     public void light(){
         this.lighted = true;
         if(opposite != null){
             Lamp.valueOf(opposite).light();
         }
         System.out.println(name() + " 绿灯亮了，下面总共应该有6个方向能看到汽车穿过！");
     }

     // 将当前灯和对应方向的灯变成红灯，并且下一条路线上的灯变绿，返回这个变绿的灯
     public Lamp blackOut(){
         this.lighted = false;
         if(opposite != null){
             Lamp.valueOf(opposite).blackOut();
         }

         Lamp nextLamp = null;
         if(next != null){
             nextLamp = Lamp.valueOf(next);
             nextLamp.light();
             System.out.println("绿灯从" + name() + "-------->切换为" + next);
             System.out.println("Time :" + new Date());
         }
         return nextLamp;
     }
 }
 </span>

LampController类，

1， 整个系统中只需要一个交通灯控制器即可，所以，这个类应该设计为单例。

2， 运行时需要指定第一个为绿的灯，所以在构造方法中指定最好。

3， 实现两个定时器分别控制直行和左转的灯，直行绿灯时间20秒，左转绿灯时间15秒

 <span style="font-size:14px">import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;

 class LampController {
     //表示当前灯
     private Lamp currentLamp;
     public LampController(){
         //指定由南向北的灯首先为绿灯
         currentLamp = Lamp.S2N;
         currentLamp.light();
         /*表示首次运行的延迟时间*/
         int festTime;
         if(currentLamp.getDirection() == Direction.CENTER) {
             festTime = 20;
         } else {
             festTime = 15;
         }

         ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
         /*创建一个定时器，如果当前灯所在路线为直行路线则亮20秒绿灯，若是左转路线则为15秒*/
         timer.scheduleWithFixedDelay(
             new Runnable() {
                 public void run() {
                     currentLamp = currentLamp.blackOut();
                     /*如果当前灯是直行路线上的灯则增加5秒钟绿灯时间*/
                     if(currentLamp.getDirection() == Direction.CENTER) {
                         try {
                             Thread.sleep(5 * 1000);
                         } catch(InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                 }
             },
             festTime,               //首次执行延时
             15,                 //执行周期
             TimeUnit.SECONDS        //指定时间单位为秒
         );
     }
 }</span>

主类（TrafficDemo）运行程序

 <span style="font-size:14px">class TrafficDemo {
     public static void main(String[] args) {
         String[] directions = new String[]{
             "S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};
         // 创建12条路线
         for(int i=0;i<directions.length;i++){
             new Road(directions[i]);
         }
         // 交通灯控制器
         new LampController();
     }
 }</span>