黑马程序员_JAVA之 交通灯管理系统

交通灯管理系统

模拟实现十字路口的交通灯管理系统逻辑，具体需求如下：

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

例如：

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

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

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

…

信号灯只考虑红灯和绿灯。

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

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

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

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

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

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

  

分析：

1.每个方向都有3条路线，即左、直，右，故共有12条路线；

2.对12条路线进行分组，南北直行组、南北左转弯组、东西直行组、东西左转弯组，以及右转弯组；

3.前四组每组都需要两个控制灯，右转弯组中4条线路各需1个控制灯且常绿，共12个控制灯；

4.前面四组中都只需考虑各组中的某一方向的控制灯的切换顺序，该方向的相对方向的控制灯切换顺序随之改变，如考虑南直行控制灯的切换顺序、南左转弯控制灯的切换顺序、东直行控制灯的切换顺序、东左转弯控制灯的切换顺序。

5.放行南北直行，再放行南北左转，再南北红灯；放行东西直行，再东西左转，再东西红灯。

交通灯管理系统——面向对象分析与设计

初步设计的对象：

    1.信号灯；

    2.信号灯控制系统；

    3.汽车；

    4.路线。

汽车行驶过程分析：

    路线跟信号灯绑定，且路线存储车辆集合，那么路线就应该有增加和减少车辆的方法；路线上的信号灯为绿时，汽车应该先判断其前面是否有其他汽车，该判断是通过路线获取。但是题目中无需体现车辆移动的过程，只需捕捉车辆穿过路口的过程，也就是捕捉路上减少一辆车的过程，故车辆不需要单独设计成为一个对象，用一个字符串表示即可。

分析后设计的对象：

    1.信号灯；

    2.信号灯控制系统；

    3.路线

实现细节：

1.每条路线上都会出现多辆车，路线上要随机只能加新的车，在灯绿期间每秒减少一辆车；

2.每条路线每隔一秒都会检查控制本路线上的等是否为绿灯，一个灯由绿变红时，应该将下一个方向的灯变绿。

（1）设计一个Lamp类来表示一个交通灯，每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。

（2）总共有12条路线，所以，系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。

（3）除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯。

（4）无论在程序的什么地方去获得某个方向的灯时，每次获得的都是同一个实例对象，所以Lamp类改用枚举来做显然具有很大的方便性，永远都只有代表12个方向的灯的实例对象。

（5）设计一个LampController类，它定时让当前的绿灯变红。

交通灯管理系统——代码设计中涉及的Java包中的类

类Executors

(java.util.concurrent包)

Executors类的方法：

    1.static ExecutorService newSingleThreadExecutor()

     创建一个使用单个worker线程的Executor，以无界队列方式来运行该线程

    2.static ExecutorService newFixedThreadPool(int nThreads)

     创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程

    3.static ScheduledExecutorService

newScheduledThreadPool(int corePoolSize)

     创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

----

接口ExecutorService

(java.util.concurrent包)

ExecutorServiceàExecutor

执行已提交的Runnable任务对象

ExecutorService接口的方法：

    1.void execute(Runnable command)

     在未来某个时间执行给定的命令(继承自Executor接口)

----

接口ScheduledExecutorService

(java.util.concurrent包)

ScheduledExecutorServiceà Executor

定期执行已提交的Runnable任务对象

ScheduledExecutorService接口的方法：

    1.ScheduledFuture<?>

schedule(Runnable command,

long delay,TimeUnit unit)

     创建并执行在给定延迟后启用的一次性操作

    2.ScheduledFuture<?>

scheduleAtFixedRate(Runnable command,

long delay,long period,TimeUnit unit)

     创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期

----

枚举TimeUnit

表示给定单元粒度的时间段

TimeUnit枚举的常量：

    1.DAYS天

    2.HOURS小时

    3.MINUTES分

    4.SECONDS秒

    5.MICROSECONDS微秒

    6.MILLISECONDS毫秒

    7.NANOSECONDS纳秒

交通灯管理系统——代码

1.自定义信号灯枚举类

/*南S北N东E西W*/

public enum Lamp {

    /*定义各个路线的枚举常量，即各个路线上的信号灯*/

    //主要考虑的四条路线

    S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",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);

    /*信号灯的基本属性*/

    //灯绿为true，灯红为false

    private boolean light;

    //与当前信号灯相反方向的信号灯，即当前信号灯对应的反向信号灯

    private String opposite;

    //当前信号灯变红时下一个变绿的信号灯

private String next;

    /*定义构造方法，枚举构造必须私有*/

    //当初始化四条主线路信号灯时设置它们对应的反向信号灯、变红时下一个变绿的信号灯以及它们的初始化信号

    private Lamp(String opposite,String next,boolean light){

        this.opposite=opposite;

        this.next=next;

        this.light=light;    

    }

    /*提供获取信号灯信号的方法*/

    public boolean isLighted(){

        return light;

    }

    /*提供设置信号灯信号的方法*/

    public void Lighted(){

        //让当前信号灯变绿

        this.light=true;

        //若当前信号灯存在相反方向的信号灯，则让所对应的反向信号灯也变绿

        if (opposite!=null) {

            Lamp.valueOf(opposite).Lighted();

        }

        System.out.println(name()+" is Green!");

    }

    public Lamp unLighted(){

        //让当前信号灯变红

        this.light=false;

        //若当前信号灯存在相反方向的信号灯，则让所对应的反向信号灯也变红

        if (opposite!=null) {

            Lamp.valueOf(opposite).unLighted();

        }

        //若当前信号灯存在下一个信号灯，则让下一个信号灯变绿

        Lamp nextLamp=null;

        if (next!=null) {

            nextLamp=Lamp.valueOf(next);

            nextLamp.Lighted();

        }

        System.out.println(name()+" is Red!");

        return nextLamp;

    }

}

2.自定义信号灯控制器类

public class LampControler {

    /*信号灯控制器的基本属性*/

    private Lamp currentLamp;

    /*定义构造方法：让S2N信号灯变绿+定义定时器用于让当前灯变红下一个灯变绿*/

    public LampControler() {

        currentLamp=Lamp.S2N;

        currentLamp.Lighted();

        //定时器

        ScheduledExecutorService timer=

Executors.newScheduledThreadPool(1);

        timer.scheduleAtFixedRate(new Runnable(){

            @Override

            public void run() {

                currentLamp=currentLamp.unLighted();

            }

        },10, 10, TimeUnit.SECONDS);

    }

}

3.自定义路线类

public class Road {

    /*路线基本属性*/

    //路线名

    private String name=null;

    //路线存储车辆集合

    private List<String> vehicles=new ArrayList<String>();

    /*路线初始化:路线名+开启线程用以在路线上添加车辆+定义定时器用以检查信号灯信号*/

    public Road(String name) {

        super();

        this.name = name;

        //建立并执行线程，让每条线路每1-10秒产生一辆车，直到999辆

        ExecutorService ThreadPool=Executors.newSingleThreadExecutor();

        ThreadPool.execute(new Runnable(){

            @Override

            public void run() {

                for(int i=1;i<1000;i++){

                    try {

                        Thread.sleep((new Random().nextInt(10)+1)*1000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    vehicles.add(Road.this.name+":"+i);

                }

            }

        });

        //定义定时器，每隔1秒检查一次路线的信号灯，当信号灯为绿时移走集合中的第一辆车

        ScheduledExecutorService timer=

Executors.newScheduledThreadPool(1);

        timer.scheduleAtFixedRate(new Runnable(){

            @Override

            public void run() {

                if(vehicles.size()>0){

                    //当路线的信号灯为绿(true)时

                    boolean light=

Lamp.valueOf(Road.this.name).isLighted();

                    if(light){

                        System.out.println(vehicles.remove(0)+" is passed!");

                    }

                }

            }

        },1,1,TimeUnit.SECONDS);

    }

}

4.主类

public class MainClass {

    public static void main(String[] args) {

        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 LampControler();

    }

}