黑马程序员---交通灯管制系统

------- android培训、java培训、期待与您交流！ ----------

交通灯管制系统的项目需要以及需求分析：

      项目需求：模拟实现十字路口的交通灯管理系统逻辑

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

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

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

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

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

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

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

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

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

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

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

对项目需求分析图如下：（为了统一编程模型，设右转车辆方向信号灯为常绿）。

逻辑图清楚之后，对整个项目进行面向对象的分析和设计。面向对象设计的最重要原则是：谁拥有数据，

谁就对外提供操作这些数据的方法。对于这个项目：设想一下有哪些对象，红绿灯，红绿灯的控制系统，

汽车，路线。汽车看到自己所在路线对应的灯绿了就穿过路口吗？

不是，还需要看其前面是否有车，看前面是否有车，该问哪个对象呢？

该问路，路中存储着车辆的集合，显然路上就应该有增加车辆和减少车辆的方法了。

再看题目，我们这里并不要体现车辆移动的过程，只是捕捉出车辆穿过路口的过程，

也就是捕捉路上减少一辆车的过程，所以，这个车并不需要单独设计成为一个对象，用一个字符串表

示就可以了。每条路上都会出现多辆车，路线上要随机增加新的车，在灯绿期间还要每秒钟减少一辆车。

首先，设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，

即系统中总共要产生12Road的实例对象。

每条路线上随机增加新的车辆，增加到一个集合中保存。每条路线每隔一秒都会检查控制本路线的灯

是否为绿，是则将本路线保存车的集合中的第一辆车移除，表示车穿过了路口。

（张老师源码示例）

package com.isoftstone.interview.traffic;

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;

/**
 * 每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。
 * 每条路线上随机增加新的车辆，增加到一个集合中保存。
 * 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
 * @author 张孝祥 www.it315.org
 *
 */
public class Road {
	private List<String> vechicles = new ArrayList<String>();
	
	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=1;i<1000;i++){
					try {
						Thread.sleep((new Random().nextInt(10) + 1) * 1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					vechicles.add(Road.this.name + "_" + i);
				}				
			}
			
		});
		
		//每隔一秒检查对应的灯是否为绿，是则放行一辆车		
		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) + " is traversing !");
							}
						}
						
					}
				},
				1,
				1,
				TimeUnit.SECONDS);
		
	}

}

LampController类：
package com.isoftstone.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();
		
		/*每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿*/		
		ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				new Runnable(){
					public  void run(){
						System.out.println("来啊");
						currentLamp = currentLamp.blackOut();
				}
				},
				10,
				10,
				TimeUnit.SECONDS);
	}
}

Lamp类：

package com.isoftstone.interview.traffic;

/**
 * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
 * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
 * 程序代码只需要控制每组灯中的一个灯即可：
 * s2n,n2s    
 * s2w,n2e
 * e2w,w2e
 * e2s,w2n
 * s2e,n2w
 * e2n,w2s
 * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，
 * 所以，可以假想它们总是绿灯。
 * @author 张孝祥 www.it315.org
 *
 */
/**/

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);
	
	private Lamp(String opposite,String next,boolean lighted){
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}


	/*当前灯是否为绿*/	
	private boolean lighted;
	/*与当前灯同时为绿的对应方向*/	
	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个方向能看到汽车穿过！");
		
	}
	
	/**
	 * 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿
	 * @return 下一个要变绿的灯
	 */	
	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;
	}
}

梳理交通灯系统知识点：

（1）Thread.sleep (new Random().nextInt(6)+1);暂停0-5之间的任意数

（2）List<String> vechicles=new ArrayList<String>();

         Vechicles.add(“abc”);

       System.out.println(  Vechicles.remove(0));//移除此列表中指定位置上的索引为0的元素，

同时向左移动所有后续元素（将其索引减 1）即移动第0个元素后，原第一个元素的索引就变成了0。remove返回的是”abc”,即集合中第0个元素，

（3）得到给定字符串所对应的枚举元素

例： enum  Fruit

{

   APPLE,BANANA,PEAR,ORANGE;

}

String fruit=”PEAR”;

Fruit f=Fruit.valueOf(fruit);//即得到了枚举Fruit的元素PEAR

（4）创建定时器

在5s以后，开始输出hello，之后每隔30s就输出一次

ScheduledExecutorService  timer1=Executors.newScheduledThreadPool(1); /*或  ScheduledExecutorService timer1=

Executors.newSingleThreadScheduledExecutor(); timer1是接口ScheduledExecutorService的子类对象 */   

 

       Timer1.scheduleAtFixedRate(new Runnable(){/*此处的scheduleAtFixedRate（）方法是接口timer1

对象所在的类实现的接口ScheduledExecutorService 中的方法*/

       public void run() {

           System.out.println(“hello”);

          

       }},

              5,

              30,

              TimeUnit.SECONDS);

Executors类中的方法

这是个工具类，里面的类都是静态的，工具类名一般以s结尾

public static ScheduledExecutorService newScheduledThreadPool(int PoolSize)    

 

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

参数：

corePoolSize - 池中所保存的线程数，即使线程是空闲的也包括在内。

返回：

新创建的安排线程池 ，即接口 ScheduledExecutorService实现类的对象

抛出：

NullPointerException - 如果 threadFactory 为 null

public static ScheduledExecutorService newSingleThreadScheduledExecutor()

创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程会代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newScheduledThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

返回：

新创建的安排执行程序，即实现接口 ScheduledExecutorService类的对象

 

public static ExecutorService newFixedThreadPool(int nThreads)

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

参数：

nThreads - 池中的线程数

返回：

新创建的线程池

 

public static ExecutorService newSingleThreadExecutor()

创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

返回：

新创建的单线程 Executor

例子：创建一个线程，并执行线程中的run()中的代码

         ExecutorService  timer2=Executors.newSingleThreadExecutor();

/*或：

ExecutorService  timer2=Executors.newFixedThreadPool(1);

此处的timer2是实现接口ExecutorService类的一个对象*/

              timer.execute(new Runnable(){

/*此处的execute（）是timer2所在的类实现的ExecutorService接口的父接口：Executor接口中的方法*/

       public void run() {

          

            System.out.println("hello world");

       }});

 

等同于如下代码：

new Thread(new Runnable()

{

public void run()

          

           { System.out.println("hello world");}

 

}).start();   

 

 

Executor接口中的方法：

void execute(Runnable command)

在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

参数：

command - 可运行的任务

 

     

ExecutorService接口

父接口是：Executor

 

ScheduledExecutorService接口

父接口是：ExecutorService

接口中的方法

ScheduledFuture<?> schedule(Runnable command,

                            long delay,

                            TimeUnit unit)

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

参数：

command - 要执行的任务

delay - 从现在开始延迟执行的时间

unit - 延迟参数的时间单位

返回：

表示挂起任务完成的 ScheduledFuture，并且其 get() 方法在完成后将返回 null

 

ScheduledFuture<?> scheduleAtFixedRate(Runnable command,

                                       long initialDelay,

                                       long period,

                                       TimeUnit unit)

创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。如果任务的任何一个执行遇到异常，则后续执行都会被取消。否则，只能通过执行程序的取消或终止方法来终止该任务。如果此任务的任何一个执行要花费比其周期更长的时间，则将推迟后续执行，但不会同时执行。

参数：

command - 要执行的任务

initialDelay - 首次执行的延迟时间

period - 连续执行之间的周期

unit - initialDelay 和 period 参数的时间单位

返回：

表示挂起任务完成的 ScheduledFuture，并且其 get() 方法在取消后将抛出异常

抛出：

RejectedExecutionException - 如果无法安排执行该任务

NullPointerException - 如果 command 为 null

IllegalArgumentException - 如果 period 小于等于 0

 

上面的定时器代码用Timer、TimerTask类可改写成如下：

法二：

    new Timer().schedule(new TimerTask()

       {

       public void run()

       {  System.out.println("hello");  }

       },

       5000,

       3000

       );

 

 

TimerTask类中的方法

TimerTask类实现了Runnable接口,有run()方法

TimerTask类中的方法:

protected TimerTask()

创建一个新的计时器任务。

run()

{}

Timer类中的方法

public void schedule(TimerTask task,

                     long delay,

                     long period)

安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。以近似固定的时间间隔（由指定的周期分隔）进行后续执行。

在固定延迟执行中，根据前一次执行的实际执行时间来安排每次执行。如果由于任何原因（如垃圾回收或其他后台活动）而延迟了某次执行，则后续执行也将被延迟。从长期来看，执行的频率一般要稍慢于指定周期的倒数（假定 Object.wait(long) 所依靠的系统时钟是准确的）。

固定延迟执行适用于那些需要“平稳”运行的重复活动。换句话说，它适用于在短期运行中保持频率准确要比在长期运行中更为重要的活动。这包括大多数动画任务，如以固定时间间隔闪烁的光标。这还包括为响应人类活动所执行的固定活动，如在按住键时自动重复输入字符。

参数：

task - 所要安排的任务。

delay - 执行任务前的延迟时间，单位是毫秒。

period - 执行各后续任务之间的时间间隔，单位是毫秒。