交通灯管理系统

(1)项目的需求

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

例如：

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

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

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

平时开车过十字路口红绿灯的时候,也知道红绿灯运行的顺序

(1)任何方向的车,向右边转弯的时候,是不需要看红绿灯

(2)在十字路口,相对方向的红绿灯的工作方式是一样的,南相对与北,东相对与西,这把它分成两对

(3)红绿灯顺序,一对直行通道绿灯直行车辆,等直行变红,还是这对的车辆可以左转,等左转变红,就轮到下一对了.所以在设计程序的时候,只需要考虑一对的红绿灯情况即可.

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

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

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

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

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

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

(2)代码的思路与体现

首先对这个项目所设计到的名词都提炼出来,包括,汽车,马路,交通灯,通知交通灯的系统,张孝祥老师说了一句面向对象设计最经典的话,谁拥有数据,那么谁就来对外提供操作这些数据的方法,通过对这句话的理解,上面涉及到的名词,汽车是在马路上跑的,那么马路就得提供自己马路上汽车的数量,只有提供了汽车数量的变化,才能让红绿灯友好的运作起来.

Road类:构造方法初始化的时候要加上那路的线路,同时在路这个类中得提供一个容器去装路上的汽车.

package cn.interview.traffic;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Road {
    //交通工具集合,用来装交通工具的
    List<String> vehicles = new ArrayList<String>();
    //name是十字路上方向对方向路的名字
    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=0;i<1000;i++){
                    try {
                        Thread.sleep((new Random().nextInt(10)+i) * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    vehicles.add(Road.this.name+"_"+i);
                }
            }
             
         });
         //在Road对象的构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿
       ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
       timer.scheduleAtFixedRate(
               new Runnable(){

                public void run() {
                    if(vehicles.size()>0){
                        boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
                        if(lighted == true){
                            System.out.println(vehicles.remove(0)+" is traversing");
                        }
                    }
                }
                   
               },
               1,
               1,
              TimeUnit.SECONDS);
    }
}

Lamp类:2种状态,true(绿灯),false(红灯),还要提供红绿灯变化的情况,绿灯亮的情况必须要保证对立两个方向的绿灯都亮,灯红的时候同时要包装对应方向的灯也要变红,同时等变红的时候,在方法中得有一个返回值,就是把红灯变成绿灯,这样这个交通灯系统才有一个良好的循环.

package cn.interview.traffic;
// S2N S2W  E2W   E2S  N2S  N2E   W2E   W2N   S2E   E2N   N2W  W2S
public enum Lamp {
    //12个方向的枚举对象
    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);
    //构造方法,第一个参数是对面方向的灯,第二个参数是下一个灯,第三个参数是灯的状态
    private Lamp(String opposite,String next,boolean lighted){
        this.opposite = opposite;
        this.next = next;
        this.lighted = lighted;
    }
    
    private Lamp(){
        
    }
    private boolean lighted;
    //表示反方向的灯,用String类型,方便传入枚举的构造方法中去
    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个方向的灯可以通过");
    }
    //红灯状态,有返回值,返回下一个灯
    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;
    }
}

LampController类:我们默认S2N方向的灯开始是绿灯,这里如何进行交通灯时间上的切换,用到了多线程的技术,我会在总结的时候,把枚举和多线程的知识补充上去.

package cn.interview.traffic;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;



public class LampController {
    private Lamp currentLamp;
    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);
    }
}

MainClass类: 直接用数组new出12条路,然后在把newRoad类,系统就能运行了.

package cn.interview.traffic;

public class MainClass {
    public static void main(String[] args) {
        //12个路口定义一个数组,把这些路口加到路上去
        String[] directions = {"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();
    }

}

(3)总结

这个项目需要对十字路口红绿灯的运行模式十分的熟悉,在对时间上的处理,比如汽车上路的时间,交通灯变化的时间,要到了JDK1.5之后的新的多线程技术,同时对于枚举的作用,在这个项目中也发挥的淋漓精致,省去了很多繁琐的代码,整个项目感觉

第一: 前期对于对象的提炼和哪个对象拥有哪些方法,这个真是需要一定的代码功力,才能完美的将对应的方法放到对应的对象去上,

第二:JDK1.5多线程Executors可以解决时间上的问题

第三:枚举的使用,简化了代码的书写,同时看完张老师的高新技术后,对于枚举的运用,对于具体问题,把枚举这个类的构造方法设计好,在把相关的参数传入对应的枚举对象中去,这点真心太重要了,在枚举传递参数的时候,一般使用的是String,而后面需要用String去调用方法是行不同的,那么这个时候枚举中的valueOf()就起作用了.

----------------------------------------------------------------------------------------------------------------------------------------------------

通过交通灯的项目,对JDK1.5后,出现的多线程以前新的技术的补充(线程池)

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

Java5的线程池分好多种：具体的可以分为两类，固定尺寸的线程池、可变尺寸连接池。

在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。

(1)固定大小的线程池，newFixedThreadPool：

package cn.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test01 {
    public static void main(String[] args) {
        //创建容量是5的线程池
        ExecutorService pools = Executors.newFixedThreadPool(3);
        //创建5个线程出来
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        //将5个线程装入池子中去
        pools.execute(t1);
        pools.execute(t2);
        pools.execute(t3);
        pools.execute(t4);
        pools.execute(t5);
        //关闭线程池
        pools.shutdown();
    }
}
class MyThread extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName()+" is running....");
        /*线程池中参数为5的时候,输出的情况
          pool-1-thread-2is running....
          pool-1-thread-4is running....
          pool-1-thread-1is running....
          pool-1-thread-3is running....
          pool-1-thread-5is running....
         * 
         * 参数为3,输出的情况
         *  pool-1-thread-2 is running....
            pool-1-thread-3 is running....
            pool-1-thread-1 is running....
            pool-1-thread-2 is running....
            pool-1-thread-3 is running....
         */
    }
}

观察参数是3和5的时候,sop输出的情况,newFixedThreadPool是指定在线程池中,有几个线程可以住在这里面,超过了这个数字的话,线程就住不进来了,其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。

(2)单任务线程池，newSingleThreadExecutor

//ExecutorService pools = Executors.newFixedThreadPool(3);
        ExecutorService pools = Executors.newSingleThreadExecutor();
sop的内容  
 pool-1-thread-1 is running....
pool-1-thread-1 is running....
pool-1-thread-1 is running....
pool-1-thread-1 is running....
pool-1-thread-1 is running....

可以看出，每次调用execute方法，其实最后都是调用了thread-1的run方法。查看API,就能发现execute方法中,就一个Runnable可运行的任务.而根据以前的多线程的知识,实现多线程的两种方式,其实最后都和Runnable这个接口搭上关系的.

(3)三、可变尺寸的线程池，newCachedThreadPool：

这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

(4)四、延迟连接池，newScheduledThreadPool  上面的交通灯和汽车时间的变化,就是用到的这个

package cn.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        //这个线程池的特点就是可以在给定的时间后运行
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
        Thread t1 = new MyThread02();
        Thread t2 = new MyThread02();
        Thread t3 = new MyThread02();
        pool.execute(t1);
        pool.schedule(t2,30,TimeUnit.SECONDS);//t1执行完毕后,30秒后,t2才执行T
        pool.scheduleAtFixedRate(t3,100,100,TimeUnit.SECONDS);//100秒后执行,如果还有的话在100+100执行,还有的话100+100*n执行
        pool.shutdown();
    }

}
class MyThread02 extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"is running...");
    }
}

这个线程池可以设置线程启动的时间,具体线程启动时间如何安排的,我已经在代码中注释起来了.