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;
/**
 * 道路类
 */
public class Road {
	
	private String name = null;
	private List<String> vechicles = new ArrayList<String>();

	public Road(String name) {
		this.name = name;
		ExecutorService pool = Executors.newSingleThreadExecutor();// 创建了含有单线程的线程池
		pool.execute(new Runnable() {// 开始执行

					public void run() {
						int i = 0;
						while (true) {
							for (i = 1; i < 100000; 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);
	}
}

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 boolean lighted;
	private String opposite;
	private String next;

	private Lamp(String opposite, String next, boolean lighted) {
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}

	private Lamp() {

	}
/**
 * 判断是否亮着
 */
	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 下面总共可以有六个方向看到汽车穿梭");

	}
/**
 * 当前灯等变暗，反向的也变暗(如果有的话)
 * 同时要返回下一个灯，这样便于操作
 * 同时也要指定下一个灯变亮
 */
	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;
	}
}

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

public class lampController {
	private Lamp currentLamp;

	private lampController() {
		//start();
	}
	/**
	 * 开始启动
	 */
	public void start() {
		this.currentLamp = Lamp.S2N;
		this.currentLamp.light();
		ScheduledExecutorService timer=Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						currentLamp=currentLamp.blackOut();//当前灯变暗
						
					}
				}, 
				10, 
				10, 
				TimeUnit.SECONDS);
	}
	/**
	 * 单例模式，返回当前类对象，
	 */
	public static lampController getlampController(){
		return new lampController();
		}
}

/**
 * 测试类，就是交通灯系统的入口类
 */
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]);
		}
		/*启动交通灯控制器
		 * 如果不启动的话，那么就四个右转弯的方向可以运行*/
		lampController controller=lampController.getlampController();
		controller.start();//启动
	}

}