交通灯管理系统-CSDN博客

今天看了张孝祥老师的“交通灯管理系统”的题目和解决方案，尝试着再自己分析这个场景，实现不一定很好，权当学习了。

首先提取下这个问题的关键要素：交通灯，路，车。三者的一种关系是车可以认为是路的“元素”，车的通过和增加都是由路负责管理的。而每一个十字路口的放行与否，都是通过交通灯控制的。路和灯应该是归属的关系，一个十字路口“拥有”一个交通灯系统。

所以我们抽象交通灯这个类，因为向右是永远放行的，所以我们可以忽略向右的这条线路，而相反方向的灯的变化是完全相同的，所以可以抽象为一个管理系统，这样其实一个路口的交通等的状态就只有4种了，而且这四种同一时刻只有一个是放行的状态。

用枚举实现交通灯：

 1 package traffic;
 2 
 3 public enum Lamp {
 4     NSStraight, NSTurn, EWStraight, EWTurn;
 5     
 6     private boolean green = false;
 7 
 8     public boolean isGreen() {
 9         return green;
10     }
11 
12     public void lighteOn() {
13         this.green = true;
14         System.out.println(this.toString());
15     }
16     public void lightOff(){
17         this.green = false;
18     }
19 
20     Lamp nextLamp() {
21         switch (this) {
22         case NSStraight:
23             lightOff();
24             NSTurn.lighteOn();
25             return NSTurn;
26         case NSTurn:
27             lightOff();
28             EWStraight.lighteOn();
29             return EWStraight;
30         case EWStraight:
31             lightOff();
32             EWTurn.lighteOn();
33             return EWTurn;
34         case EWTurn:
35             lightOff();
36             NSStraight.lighteOn();
37             return NSStraight;
38         }
39         return null;
40     }
41     @Override
42     public String toString(){
43         switch (this) {
44         case NSStraight:
45             return "----------南北方向直行";
46         case NSTurn:
47             return "----------南北方向左转";
48         case EWStraight:
49             return "----------东西方向直行";
50         case EWTurn:
51             return "----------东西方向左转";
52         }
53         return null;
54         
55     }
56 }

交通灯的轮换相对来说比较独立，和路的耦合不算大，每个路口可以独立于路配备一个交通灯，这里先用线程实现模拟交通灯的切换规则：

 1 package traffic;
 2 
 3 public class LampControl implements Runnable{
 4     Lamp NSStraight = Lamp.NSStraight;
 5     Lamp NSTurn = Lamp.NSTurn;
 6     Lamp EWStraight = Lamp.EWStraight;
 7     Lamp EWTurn = Lamp.EWTurn;
 8     
 9     Lamp currentLamp = NSStraight;
10     
11     public Lamp getCurrentLamp() {
12         return currentLamp;
13     }
14     
15     int StraightTime = 10000;//ms
16     int TurnTime = 10000;
17     @Override
18     public void run() {
19         currentLamp.lighteOn();
20         while(true){
21             try {
22                 Thread.sleep(StraightTime);
23                 currentLamp = currentLamp.nextLamp();
24                 Thread.sleep(TurnTime);
25                 currentLamp = currentLamp.nextLamp();
26                 Thread.sleep(StraightTime);
27                 currentLamp = currentLamp.nextLamp();
28                 Thread.sleep(TurnTime);
29                 currentLamp = currentLamp.nextLamp();
30                 
31             } catch (InterruptedException e) {
32                 e.printStackTrace();
33             }
34         }
35         
36         
37     }
38     
39 }

这样在主函数中可以通过独立的线程模拟单独的交通灯切换功能。

接下来模拟十字路口的车辆过往的展示，一个十字路口有一个交通灯系统，抛开向右自由行驶的路线，有8条行车路线，每条路线用一个集合存放这条路线上的车，适当的时候放行。

 1 package traffic;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public enum SingleRoad {
 7     NSRoad, SNRoad, NSLRoad, SNLRoad, EWRoad, WERoad, EWLRoad, WELRoad;
 8     int num = 1;
 9     List<Integer> list = new ArrayList<Integer>();
10 
11     public void addCar() {
12         this.list.add(num++);
13             System.out.println(this.toString()+": "+num + "号车正在等待");
14     }
15 
16     public void passCar() {
17         if(this.list.size()>0){
18             Integer i = this.list.remove(0);
19             System.out.println(this.toString()+": "+ i + "号车正在过马路");
20         }
21     }
22 
23     @Override
24     public String toString() {
25         switch (this) {
26         case NSRoad:
27             return "北向南";
28         case SNRoad:
29             return "南向北";
30         case NSLRoad:
31             return "北向南左";
32         case SNLRoad:
33             return "南向北左";
34         case EWRoad:
35             return "东向西";
36         case WERoad:
37             return "西向东";
38         case EWLRoad:
39             return "东向西左";
40         case WELRoad:
41             return "西向东左";
42         }
43         return null;
44     }
45 
46 }

在创建一个Road类管理一个十字路口的情形，随机的往每条线路上增加车辆并等待，当这条线路的控制灯亮的时候，放行这条线路上的车。

 1 package traffic;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.Random;
 6 
 7 public class Road implements Runnable {
 8     LampControl lc = new LampControl();
 9     List<SingleRoad> listRoads = new ArrayList<SingleRoad>();
10     SingleRoad NSRoad = SingleRoad.NSRoad;
11     SingleRoad SNRoad = SingleRoad.SNRoad;
12     SingleRoad NSLRoad = SingleRoad.NSLRoad;
13     SingleRoad SNLRoad = SingleRoad.SNLRoad;
14     SingleRoad EWRoad = SingleRoad.EWRoad;
15     SingleRoad WERoad = SingleRoad.WERoad;
16     SingleRoad EWLRoad = SingleRoad.EWLRoad;
17     SingleRoad WELRoad = SingleRoad.WELRoad;
18 
19     public Road(LampControl lc) {
20         this.lc = lc;
21         listRoads.add(NSRoad);
22         listRoads.add(NSLRoad);
23         listRoads.add(SNRoad);
24         listRoads.add(SNLRoad);
25         listRoads.add(EWLRoad);
26         listRoads.add(EWRoad);
27         listRoads.add(WELRoad);
28         listRoads.add(WERoad);
29     }
30 
31     void method(){
32         while(true){
33             Lamp l = lc.getCurrentLamp();
34             switch (l) {
35             case NSStraight:
36                 NSRoad.passCar();
37                 SNRoad.passCar();
38                 passTime();
39                 break;
40             case NSTurn:
41                 NSLRoad.passCar();
42                 SNLRoad.passCar();
43                 passTime();
44                 break;
45             case EWStraight:
46                 EWRoad.passCar();
47                 WERoad.passCar();
48                 passTime();
49                 break;
50             case EWTurn:
51                 EWLRoad.passCar();
52                 WELRoad.passCar();
53                 passTime();
54                 break;
55             }
56         }
57         
58     }
59     
60     private void passTime(){
61         try {
62             //一秒过一辆
63             Thread.sleep(1000);
64         } catch (InterruptedException e) {
65             e.printStackTrace();
66         }
67     }
68     
69     @Override
70     public void run() {
71         while (true) {
72             try {
73                 //1--3秒随机添加一辆车
74                 Thread.sleep((new Random().nextInt(3) + 1) * 1000);
75             } catch (InterruptedException e) {
76                 e.printStackTrace();
77             }
78             int index = new Random().nextInt(8);
79             SingleRoad sr = listRoads.get(index);
80             sr.addCar();
81         }
82 
83     }
84 
85 }

这样当我们实际运行的时候就有三个线程了，一个线程专门负责灯的转换，一个线程专门负责车的添加，一个线程负责灯亮的时候车的放行。

1 public static void main(String[] args) {
2         LampControl lc1 = new LampControl();
3         Road road = new Road(lc1);
4         new Thread(lc1).start();
5         new Thread(road).start();
6         road.method();
7     }