package heimablog.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 adanac

 */

public class Road {

	//车并不需要定义一个实体类，将车以字符串的形式定义到数组中即可

	//通过分析车的特点，车有增加和减少的方法，所以链表结构是符合车的存储特点的

	//为什么不写ArrayList集合呢 因为面向接口编程

	/*接口 List<E>

	所有超级接口：

	Collection<E>, Iterable<E>

	所有已知实现类（部分）：

	AbstractList, ArrayList, AttributeList, LinkedList, Vector*/

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

	private String name;

	//在构造方法中不断的创建车

	public Road(String name) {

		this.name = name;

		//线程库,使用线程库来创建一个线程，相当于一个线程池

		ExecutorService pool = Executors.newSingleThreadExecutor();

		//相当于new一个Runnable的实现类对象

		pool.execute(new Runnable() {

			@Override

			public void run() {

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

					try {

						Thread.sleep(1000 * (new Random().nextInt(10) + 1));//sleep随机数，随机值1~10

					} catch (InterruptedException e) {

						e.printStackTrace();

					}

					vehicls.add(Road.this.name + "_" + i);//内部类访问外部类,可以在构造函数的参数String前加final,也可以使用外部类名.this.变量名

				}

			}

		});

		//定时器每隔1s检查绿灯是否变亮

		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);

		timer.scheduleAtFixedRate(new Runnable() {

			@Override

			public void run() {

				//定义变量lighted判断当前线路的灯是否是绿灯

				boolean lighted = Lamp.valueOf(Road.this.name).isLighted();

				if (lighted) {

					//如果是绿灯并且检查到路上有车，则放行第一辆车

					if (vehicls.size() > 0) {

						System.out.println(vehicls.remove(0));

					}

				}

			}

		}, 1, 1, TimeUnit.SECONDS);

	}

}

/**

 *Road类中使用了Java多线程：类Executors主要的工厂方法，也是创建线程池的方法，创建一个单线程化的Executor)：newSingleThreadExecutor()

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

 *可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

 */

package heimablog.traffic;

/**

 * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。

 * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红.

 * 程序代码只需要控制每组灯中的一个灯即可：

 * s2n,n2s

 * s2w,n2e

 * e2w,w2e

 * e2s,w2n

 * s2e,n2w

 * e2n,w2s

 * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，

 * 所以，可以假想它们总是绿灯。

 * @author adanac

 */

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

	/* 与当前灯同时为绿的对应方向(为了避免传递的错误，我们将灯Lamp变为字符串，传递对应灯的名字字符串) */

	private String opposite;

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

	private String next;

	/* 当前灯是否为绿 */

	private boolean lighted;

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

		this.opposite = opposite;

		this.next = next;

		this.lighted = lighted;

	}

	//定义一个返回灯是否亮着的方法

	public boolean isLighted(){

		return lighted;

	}

	//让灯变绿，并且让对应方向的灯也变绿

	public void light(){

		this.lighted = true;

		if (opposite != null) {

			Lamp.valueOf(opposite).light();

		}

		System.out.println(name() + " 灯亮了,有6个方向的车在移动");

	}

	// 让灯变红，并且让对应方向的灯也变红，也要让下一个方向的灯变绿

	public Lamp blackOut(){

		this.lighted = false;

		if (opposite != null) {

			System.out.println("绿灯由" + name() +" -----> " + next);

			Lamp.valueOf(opposite).blackOut();

		}

		Lamp nextLamp = null;

		//定义一个避免死循环的解决办法

		if (next != null) {

			nextLamp = Lamp.valueOf(next);

			nextLamp.light();

		}

		return nextLamp;

	}

}

package heimablog.traffic;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

//定义一个灯的控制器

public class LampController {

	//定义一个变量：当前的灯

	private Lamp currentlLamp;

	//定义构造方法， 构造方法上来 应该让某一个灯变绿

	public LampController() {

		currentlLamp = Lamp.S2N;

		currentlLamp.light();

		//做个定时器，让每隔10s绿灯变红灯,并让下一个方向的灯变绿

		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);

		timer.scheduleAtFixedRate(new Runnable() {

			@Override

			public void run() {

				currentlLamp = currentlLamp.blackOut();

			}

		}, 10, 10, TimeUnit.SECONDS);

	}

}

package heimablog.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();

	}

}