A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 彭卫红 中级黑马   /  2014-9-4 00:19  /  1206 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 彭卫红 于 2014-9-4 00:26 编辑

  1. <p><p><font color="seagreen" size="5">没有写的可以当做参考</font></p><p><p>
  2. </p><p>
  3. </p><p>import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Random;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.ScheduledExecutorService;
  9. import java.util.concurrent.TimeUnit;

  10. /**
  11. * 用集合表示路,12条路,就是12Road对象,系统开始要有12个对象, 路上随机增加车,就是在集合增加一个对象保持,
  12. * 每条路线每隔一秒都会检查控制本路线的灯是否为绿,就是把没条路第一个对象去除所以集合是有顺序的
  13. */
  14. public class Road {
  15.         private List<String> vechicles = new ArrayList<String>();
  16.         // 集合,有顺序存储车元素
  17.         private String name = null;
  18.         // 定义路上对应的灯

  19.         public Road(String name) {
  20.                 // 因为路已初始化就会有车辆,所以代码应该封装在路的构造函数中
  21.                 this.name = name;
  22.                 // 路创建出对象时候就开始 模拟车辆不断随机上路的过程
  23.                 /*
  24.                  * ExecutorService线程池,Executors 类为这些 Executor 提供了便捷的工厂方法。
  25.                  * newSingleThreadExecutor()创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。
  26.                  */
  27.                 ExecutorService pool = Executors.newSingleThreadExecutor();
  28.                 /*
  29.                  * void execute(Runnable command)在未来某个时间执行给定的命令。
  30.                  * 该命令可能在新的线程、已入池的线程或者正调用的线程中执行, 这由 Executor 实现决定。
  31.                  */
  32.                 pool.execute(new Runnable() {
  33.                         public void run() {
  34.                                 for (int i = 1; i < 1000; i++) {
  35.                                         try {
  36.                                                 // 产生1到10秒随机数
  37.                                                 Thread.sleep((new Random().nextInt(10) + 1) * 1000);
  38.                                         } catch (InterruptedException e) {
  39.                                                 e.printStackTrace();
  40.                                         }
  41.                                         // 集合里面增加一个车,名字是路名+顺序数字
  42.                                         vechicles.add(Road.this.name + "_" + i);
  43.                                 }
  44.                         }
  45.                 });
  46.                 // 每隔一秒检查对应的灯是否为绿,是则放行一辆车创建一个定时器的线程池
  47.                 /*
  48.                  * public interface ScheduledExecutorServiceextends ExecutorService 一个
  49.                  * ExecutorService,可安排在给定的延迟后运行或定期执行的命令。
  50.                  */
  51.                 ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
  52.                 /*
  53.                  * scheduleAtFixedRate(Runnable command, long initialDelay, long period,
  54.                  * TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;
  55.                  * 也就是将在 initialDelay后开始执行,然后在 initialDelay+period 后执行,</p><p>                 * 接着在 initialDelay + 2 * period后执行,依此类推。
  56.                  */
  57.                 timer.scheduleAtFixedRate(new Runnable() {
  58.                         public void run() {
  59.                                 // 如果路上有车,就每隔1秒判断一次灯,若灯为绿,那么就将第一辆车取走
  60.                                 if (vechicles.size() > 0) {
  61.                                         boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
  62.                                         if (lighted) {
  63.                                                 System.out.println(vechicles.remove(0)
  64.                                                                 + " is traversing !");
  65.                                         }
  66.                                 }
  67.                         }
  68.                 }, 1, 1, TimeUnit.SECONDS);// TimeUnit.SECONDS枚举

  69.         }
  70. }
  71. /**
  72. * 枚举中每个Lamp元素代表一个方向上的灯,总共有12个方向,所以有12个元素
  73. * 例如正南、正北2灯是一组,一起红或者绿,所以只要控制正南灯保持正北灯就可以了,这样一共有4组,
  74. * 由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制,可以假想它们总是绿灯。
  75. */
  76. public enum Lamp {
  77.         /*
  78.          * 12个枚举元素各表示一个方向的控制灯,4组灯中只要控制每一组的一个灯变化就可以,另个保持一致
  79.          */
  80.         S2N("N2S", "S2W", false), S2W("N2E", "E2W", false), E2W("W2E", "E2S", false), E2S
  81.         ("W2N", "S2N", false),
  82.         /*
  83.          * 下面元素表示与上面的元素一组的灯,所以与上面保持一致就可,“相反方向灯”和“下一个灯”不考虑,不然可能死循环
  84.          */
  85.         N2S(null, null, false), N2E(null, null, false), W2E(null, null, false), W2N(
  86.                         null, null, false),
  87.                         // 对于右拐弯的灯,可以认为始终是绿灯
  88.         S2E(null, null, true), E2N(null, null, true), N2W(null, null, true), W2S(
  89.                         null, null, true);
  90.         private Lamp(String opposite, String next, boolean lighted) {
  91.                 // 构造方法,3个参数,同组对应的灯,下个灯,红绿情况
  92.                 this.opposite = opposite;
  93.                 this.next = next;
  94.                 this.lighted = lighted;
  95.         }
  96.         // 构造方法传递的参数,true绿灯
  97.         private boolean lighted;
  98.         // 定义灯的相反方向的灯
  99.         private String opposite;
  100.         // 当前灯变红时下一个变绿的灯(相邻的灯)
  101.         private String next;
  102.         /**
  103.          * 构造方法传递的参数的方法,true绿灯
  104.          */
  105.         public boolean isLighted() {
  106.                 return lighted;
  107.         }
  108.         /**
  109.          * 灯变绿的方法 某个灯变绿时,它同组对应方向的灯也要变绿
  110.          */
  111.         public void light() {
  112.                 this.lighted = true;// 灯变绿
  113.                 if (opposite != null) {// 它同组对应方向的灯存在情况执行
  114.                         // 重要:valueOf方法,根据值来反向获取Lamp对象: Lamp lamp = Lamp.valueOf(opposite);
  115.                         Lamp.valueOf(opposite).light();
  116.                 }
  117.                 // 重要:name()返回此枚举常量的名称,在其枚举声明中对其进行声明。
  118.                 System.out.println(name() + " lamp is green,下面总共应该有6个方向能看到汽车穿过!");
  119.         }
  120.         /**
  121.          * 灯变红的方法 某个灯变红时,对应方向的灯也要变红,并且下一个方向的灯要变绿
  122.          *
  123.          * @return 下一个要变绿的灯
  124.          */
  125.         public Lamp blackOut() {
  126.                 this.lighted = false;// 灯变红
  127.                 if (opposite != null) {
  128.                         Lamp.valueOf(opposite).blackOut();
  129.                 }
  130.                 Lamp nextLamp = null;// 设置下一个灯
  131.                 if (next != null) {// 下一个灯有执行
  132.                         nextLamp = Lamp.valueOf(next);
  133.                         System.out.println("绿灯从" + name() + "-------->切换为" + next);
  134.                         nextLamp.light();
  135.                 }
  136.                 return nextLamp;
  137.         }
  138. }
  139. import java.util.concurrent.Executors;
  140. import java.util.concurrent.ScheduledExecutorService;
  141. import java.util.concurrent.TimeUnit;
  142. /**
  143. * 灯控制器,每隔10秒将当前绿灯变为红灯,并让下一个方向的灯变绿
  144. */
  145. //控制灯的亮
  146. public class LampController {
  147.         // 定义当前的灯
  148.         private Lamp currentLamp;
  149.         public LampController() {
  150.                 //设定刚开始让由南向北的灯变绿;
  151.                 currentLamp = Lamp.S2N;
  152.                 currentLamp.light();
  153.                 // 定时器每隔10秒将当前绿灯变为红灯,并让下一个方向的灯变绿
  154.                 ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
  155.                 timer.scheduleAtFixedRate(new Runnable() {
  156.                         public void run() {
  157.                                 currentLamp.blackOut();
  158.                         }
  159.                 }, 10, 10, TimeUnit.SECONDS);
  160.         }
  161. }
  162. /*运行类,在开始运行后
  163. * 产生12个方向的路线,并产生整个交通灯系统让其开始工作
  164. * */
  165. public class MainClass {
  166.         public static void main(String[] args) {
  167.                 /* 产生12个方向的路线 */
  168.                 String[] directions = new String[] { "S2N", "S2W", "E2W", "E2S", "N2S",
  169.                                 "N2E", "W2E", "W2N", "S2E", "E2N", "N2W", "W2S" };
  170.                 for (int i = 0; i < directions.length; i++) {
  171.                         new Road(directions[i]);
  172.                 }
  173.                 /* 产生整个交通灯系统 */
  174.                 new LampController();
  175.         }
  176. }
  177. </p></p></p>
复制代码

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马