《交通灯管理》观后感

花了几个小时把张老师《交通灯管理》看完了，觉得需要学习的有几个方面：

1.用Executors来管理线程，以前只会傻傻的让类实现Runnable接口或者继承Thread，再实现run函数，然后再new Thread(this).run()，这样死板的写法。Executors让我见识到了另一种新的写法。

2.原来有enum这样的类，而且枚举类中的的元素是枚举类的实例化对象，枚举类的构造函数的访问权限为private。

3.最最重要的是，所有的问题，都应该----简化，建模----找到对象----分析清楚，再写代码。

张孝祥老师一张图，把12条路线简化为4条，真的是分析能力很强。

 

下面是代码：

package com.TrafficDemo.src;
import java.util.*;
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> cars = new ArrayList<String>();
	//路的名称,如S2N（由南向北的路），总共有12条（包括转弯）
	private String roadName = null;

	
	//构造函数
	public Road(String roadName){
		
		this.roadName=roadName;
		
		//使用多线程，防止在添加车时将主线程阻塞在此
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		executorService.execute(new Runnable(){
		
			public void run(){
				
				//添加1000辆车
				for(int i=0;i<1000;i++){
					
					try {
						//线程休眠是以毫秒为单位
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//车名为路名+序号
		            cars.add(Road.this.roadName+(i+1));
				}
			}
		});
		
		//每一秒钟检查一次，如果本道路的灯为绿色，那么就放车通过
		ScheduledExecutorService sExecutors = Executors.newScheduledThreadPool(1);
		sExecutors.scheduleAtFixedRate(
				new Runnable(){
					
					public void run(){
						
						//检查本道路的灯是否为绿色
						boolean green=Light.valueOf(Road.this.roadName).getLight();
						
						if(green){
							
							System.out.println(cars.remove(0) + " 正在通过路口.");
						}
					}
				},
				1, 
				1, 
				TimeUnit.SECONDS);
	}
}

Light类：

package com.TrafficDemo.src;
/*
 * 交通灯，枚举
 */
public enum Light {

	//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),
	E2N(null,null,true),N2W(null,null,true),W2S(null,null,true),S2E(null,null,true);
	
	//是否亮了绿灯
	private boolean green = false;
	//与之对应的灯
	private String correLight = null;
	//下一个灯
	private String nextLight = null;
	
	//构造函数，枚举的构造函数为private
	private Light(String correLight,String nextLight,boolean green){
		
		this.correLight=correLight;
		this.nextLight=nextLight;
		this.green=green;
	}

	//灯亮绿灯
	public void lightGreen(){
		
		this.green=true;
		System.out.println(this + " 的绿灯亮了 ");
		//此灯亮了，与之对应的灯也同样的亮
		if(this.correLight != null){
			
			Light.valueOf(this.correLight).lightGreen();
		}
	} 
	//灯转为红灯，那么下一个灯为绿灯
	public Light lightRed(){
		
		this.green=false;
		Light next=null;
		
		if(this.correLight != null){
			
			Light.valueOf(this.correLight).lightRed();
		}
		
		//下一灯变为绿灯
		if(this.nextLight != null){
			
			next = Light.valueOf(this.nextLight);
			
			next.lightGreen();
		}
		
		return next;
	}

	public boolean getLight() {
		// TODO Auto-generated method stub
		return this.green;
	}
}

LightController类：

package com.TrafficDemo.src;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/*
 * 交通灯控制器
 */
public class LightController {

	//当前的灯
	private Light currentLight;
	public LightController(){
		
		currentLight=Light.S2N;
		currentLight.lightGreen();
		
		//每十秒钟切换一次灯
		ScheduledExecutorService sExecutorService = Executors.newScheduledThreadPool(1);
		sExecutorService.scheduleAtFixedRate(
				new Runnable(){
					
					public void run(){
						
						currentLight = currentLight.lightRed();
					}
				}, 
				10,
				10,
				TimeUnit.SECONDS);
		
	}
}

主函数：

package com.TrafficDemo.src;
//用于测试的主函数
public class Main {

	public static void main(String[] args){
		
		System.out.println("交通灯程序开始运行...:");
		
		String[] direction=new String[]{
				
				"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","E2N","N2W","W2S","S2E"
		};
		//初始化12条路
		for(int i=0;i<direction.length;i++){
			
			new Road(direction[i]);
		}
		//初始化交通灯控制器
		new LightController();
	}
}