本帖最后由 彭卫红 于 2014-9-4 00:26 编辑
- <p><p><font color="seagreen" size="5">没有写的可以当做参考</font></p><p><p>
- </p><p>
- </p><p>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;
- /**
- * 用集合表示路,12条路,就是12Road对象,系统开始要有12个对象, 路上随机增加车,就是在集合增加一个对象保持,
- * 每条路线每隔一秒都会检查控制本路线的灯是否为绿,就是把没条路第一个对象去除所以集合是有顺序的
- */
- public class Road {
- private List<String> vechicles = new ArrayList<String>();
- // 集合,有顺序存储车元素
- private String name = null;
- // 定义路上对应的灯
- public Road(String name) {
- // 因为路已初始化就会有车辆,所以代码应该封装在路的构造函数中
- this.name = name;
- // 路创建出对象时候就开始 模拟车辆不断随机上路的过程
- /*
- * ExecutorService线程池,Executors 类为这些 Executor 提供了便捷的工厂方法。
- * newSingleThreadExecutor()创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。
- */
- ExecutorService pool = Executors.newSingleThreadExecutor();
- /*
- * void execute(Runnable command)在未来某个时间执行给定的命令。
- * 该命令可能在新的线程、已入池的线程或者正调用的线程中执行, 这由 Executor 实现决定。
- */
- pool.execute(new Runnable() {
- public void run() {
- for (int i = 1; i < 1000; i++) {
- try {
- // 产生1到10秒随机数
- Thread.sleep((new Random().nextInt(10) + 1) * 1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- // 集合里面增加一个车,名字是路名+顺序数字
- vechicles.add(Road.this.name + "_" + i);
- }
- }
- });
- // 每隔一秒检查对应的灯是否为绿,是则放行一辆车创建一个定时器的线程池
- /*
- * public interface ScheduledExecutorServiceextends ExecutorService 一个
- * ExecutorService,可安排在给定的延迟后运行或定期执行的命令。
- */
- ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
- /*
- * scheduleAtFixedRate(Runnable command, long initialDelay, long period,
- * TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;
- * 也就是将在 initialDelay后开始执行,然后在 initialDelay+period 后执行,</p><p> * 接着在 initialDelay + 2 * period后执行,依此类推。
- */
- timer.scheduleAtFixedRate(new Runnable() {
- public void run() {
- // 如果路上有车,就每隔1秒判断一次灯,若灯为绿,那么就将第一辆车取走
- 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);// TimeUnit.SECONDS枚举
- }
- }
- /**
- * 枚举中每个Lamp元素代表一个方向上的灯,总共有12个方向,所以有12个元素
- * 例如正南、正北2灯是一组,一起红或者绿,所以只要控制正南灯保持正北灯就可以了,这样一共有4组,
- * 由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制,可以假想它们总是绿灯。
- */
- public enum Lamp {
- /*
- * 12个枚举元素各表示一个方向的控制灯,4组灯中只要控制每一组的一个灯变化就可以,另个保持一致
- */
- 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) {
- // 构造方法,3个参数,同组对应的灯,下个灯,红绿情况
- this.opposite = opposite;
- this.next = next;
- this.lighted = lighted;
- }
- // 构造方法传递的参数,true绿灯
- private boolean lighted;
- // 定义灯的相反方向的灯
- private String opposite;
- // 当前灯变红时下一个变绿的灯(相邻的灯)
- private String next;
- /**
- * 构造方法传递的参数的方法,true绿灯
- */
- public boolean isLighted() {
- return lighted;
- }
- /**
- * 灯变绿的方法 某个灯变绿时,它同组对应方向的灯也要变绿
- */
- public void light() {
- this.lighted = true;// 灯变绿
- if (opposite != null) {// 它同组对应方向的灯存在情况执行
- // 重要:valueOf方法,根据值来反向获取Lamp对象: Lamp lamp = Lamp.valueOf(opposite);
- Lamp.valueOf(opposite).light();
- }
- // 重要:name()返回此枚举常量的名称,在其枚举声明中对其进行声明。
- 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;
- }
- }
- import java.util.concurrent.Executors;
- import java.util.concurrent.ScheduledExecutorService;
- import java.util.concurrent.TimeUnit;
- /**
- * 灯控制器,每隔10秒将当前绿灯变为红灯,并让下一个方向的灯变绿
- */
- //控制灯的亮
- 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() {
- currentLamp.blackOut();
- }
- }, 10, 10, TimeUnit.SECONDS);
- }
- }
- /*运行类,在开始运行后
- * 产生12个方向的路线,并产生整个交通灯系统让其开始工作
- * */
- public class MainClass {
- public static void main(String[] args) {
- /* 产生12个方向的路线 */
- 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]);
- }
- /* 产生整个交通灯系统 */
- new LampController();
- }
- }
- </p></p></p>
复制代码 |
|