升级交通灯问题(可以循环模拟的车辆的来回)

Sword

本帖最后由 forward 于 2013-8-9 18:43 编辑

在我看到了交通灯的项目后，我心里有一个问题，就是老师模拟的是每一条路上999辆车，但是我认为，只要交通灯一旦启动，就会有源源不端车辆通过。
要是把老师的每条路上999辆，改为2辆模拟，就会出现这种状况。

N2S  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2N  lamp is green 下面总共可以有六个方向看到汽车穿梭
N2S_1  is traversing!
N2S_2  is traversing!
N2W_1  is traversing!
E2N_1  is traversing!
W2S_1  is traversing!
N2W_2  is traversing!
S2N_1  is traversing!
S2E_1  is traversing!
--来了--
绿灯从S2N-------->切换为S2W
N2E  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2W  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2W_1  is traversing!
N2E_1  is traversing!
S2E_2  is traversing!
W2S_2  is traversing!
S2W_2  is traversing!
N2E_2  is traversing!
E2N_2  is traversing!
--来了--
绿灯从S2W-------->切换为E2W
W2E  lamp is green 下面总共可以有六个方向看到汽车穿梭
E2W  lamp is green 下面总共可以有六个方向看到汽车穿梭
E2W_1  is traversing!
W2E_1  is traversing!
E2W_2  is traversing!
W2E_2  is traversing!
--来了--
绿灯从E2W-------->切换为E2S
W2N  lamp is green 下面总共可以有六个方向看到汽车穿梭
E2S  lamp is green 下面总共可以有六个方向看到汽车穿梭
E2S_1  is traversing!
W2N_1  is traversing!
E2S_2  is traversing!
W2N_2  is traversing!
--来了--
绿灯从E2S-------->切换为S2N
N2S  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2N  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2N_2  is traversing!
--来了--
绿灯从S2N-------->切换为S2W
N2E  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2W  lamp is green 下面总共可以有六个方向看到汽车穿梭
--来了--
绿灯从S2W-------->切换为E2W
W2E  lamp is green 下面总共可以有六个方向看到汽车穿梭
E2W  lamp is green 下面总共可以有六个方向看到汽车穿梭
--来了--
绿灯从E2W-------->切换为E2S
W2N  lamp is green 下面总共可以有六个方向看到汽车穿梭
E2S  lamp is green 下面总共可以有六个方向看到汽车穿梭
--来了--
绿灯从E2S-------->切换为S2N
N2S  lamp is green 下面总共可以有六个方向看到汽车穿梭
S2N  lamp is green 下面总共可以有六个方向看到汽车穿梭

其实999辆和2辆都是一样的，都会过完，我认为可以是路上的不断的来，只要来了，就进行数，然后过一段时间，就汇报一下，然后在重新计数。

这样设计比较好将Road更改一下：
public class Road {
      private List<String> vechicles = new ArrayList<String>();
      private String name = null;
private int count=0;//车辆计数器
private int SumCount=0;//存储总车辆
private Calendar calendar=new GregorianCalendar();//日历
      public Road(String name) {
            this.name = name;
            ExecutorService pool = Executors.newSingleThreadExecutor();
            pool.execute(new Runnable() {

                     public void run() {
                              int i=0;
                              while (true) {
            int startHour=calendar.get(Calendar.HOUR);//获得开始小时
                                    for (i = 1; i < 100000; i++) {//间隔是一个小时一个小时之内不可能有10万辆车上路
                                             try {
                                                      Thread.sleep((new Random().nextInt(10) + 1) * 1000);
                                             } catch (InterruptedException e) {
                                                      e.printStackTrace();
                                             }
                                             count++;
                                             vechicles.add(Road.this.name + "_" + i);
                                    }
                                    int endHour=calendar.get(Calendar.HOUR);//获得结束小时
                                    int jiange=(endHour-startHour);
                                    if(jiange==2){
                                             SumCount+=count;
                                             System.out.println(Road.this.name+"一个小时之内已经有"+vechicles+"车辆");
                                             startHour=endHour;//将结束时间给赋给初始时间，下一秒就会变成当前系统时间小时，这只是起到一个重新计数的作用，也可以把100赋给初始时间
                                             i=0;//计数重新开始，然后车辆的编号也开始重新命名
                                             vechicles.removeAll(vechicles);//将车辆集合清空
                                    }

                              }

                     }
            });

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

请大家看一下对与这个有什么好的提议吗？？请大家指教！

佟都 · 佟都

本帖最后由佟都于 2013-8-7 19:20 编辑

forward 发表于 2013-8-7 17:28
我的意思不是限行，而是想循环的模拟车辆上路

感觉你的所谓的“模拟”，只是在原来的基础上增加了车辆数（以防限行），
然后强制每小时统计一次，清空一次。

这和运行原代码3分钟，然后手动停止，不是一样的么？（车辆数也不存在限行）

虽然，最后确实实现了循环。

p.s.
1、这里的“循环的模拟车辆上路”，改成“循环模拟交通灯问题”可能更贴切些。
因为测试场景（路，还是那12条路；灯，还是那12盏灯）没变，只不过测试数据（路上的车）变了。
2、始终觉得升级的是统计每小时车流量。

杨增坤 · 杨增坤

佟都发表于 2013-8-7 17:16
将每条路上的车数从999改为2后，实际上是对该方向上的车辆限行。
运行结果是，这个方向上通过2辆车后不在有 ...

我的意思不是限行，而是想循环的模拟车辆上路

佟都 · 佟都

本帖最后由佟都于 2013-8-7 17:29 编辑

将每条路上的车数从999改为2后，实际上是对该方向上的车辆限行。
运行结果是，这个方向上通过2辆车后不在有车通过。
下面是测试结果：

S2N灯：变绿
------------------------
当前全部交通灯状态：
S2N-GREEN, S2W-RED, E2W-RED, E2S-RED,
N2S-GREEN, N2E-RED, W2E-RED, W2N-RED,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
E2S方向：第1辆车，上路……
N2W方向：第1辆车，上路……
N2W方向：第1辆车，通行！
S2N方向：第1辆车，上路……
S2N方向：第1辆车，通行！
E2N方向：第1辆车，上路……
E2N方向：第1辆车，通行！
S2W方向：第1辆车，上路……
E2W方向：第1辆车，上路……
E2N方向：第2辆车，上路……
E2N方向：第2辆车，通行！
S2E方向：第1辆车，上路……
S2E方向：第1辆车，通行！
S2W方向：第2辆车，上路……
W2E方向：第1辆车，上路……
W2S方向：第1辆车，上路……
W2S方向：第1辆车，通行！
N2W方向：第2辆车，上路……
N2W方向：第2辆车，通行！
S2N方向：第2辆车，上路……
S2N方向：第2辆车，通行！
E2S方向：第2辆车，上路……
E2W方向：第2辆车，上路……
N2S方向：第1辆车，上路……
N2S方向：第1辆车，通行！
N2E方向：第1辆车，上路……
W2N方向：第1辆车，上路……
S2N灯：变红
S2W灯：变绿
------------------------
当前全部交通灯状态：
S2N-RED, S2W-GREEN, E2W-RED, E2S-RED,
N2S-RED, N2E-GREEN, W2E-RED, W2N-RED,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
S2W方向：第1辆车，通行！
W2N方向：第2辆车，上路……
N2E方向：第1辆车，通行！
S2W方向：第2辆车，通行！
W2E方向：第2辆车，上路……
S2E方向：第2辆车，上路……
S2E方向：第2辆车，通行！
N2E方向：第2辆车，上路……
N2E方向：第2辆车，通行！
W2S方向：第2辆车，上路……
W2S方向：第2辆车，通行！
N2S方向：第2辆车，上路……
S2W灯：变红
E2W灯：变绿
------------------------
当前全部交通灯状态：
S2N-RED, S2W-RED, E2W-GREEN, E2S-RED,
N2S-RED, N2E-RED, W2E-GREEN, W2N-RED,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
E2W方向：第1辆车，通行！
W2E方向：第1辆车，通行！
E2W方向：第2辆车，通行！
W2E方向：第2辆车，通行！
E2W灯：变红
E2S灯：变绿
------------------------
当前全部交通灯状态：
S2N-RED, S2W-RED, E2W-RED, E2S-GREEN,
N2S-RED, N2E-RED, W2E-RED, W2N-GREEN,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
E2S方向：第1辆车，通行！
W2N方向：第1辆车，通行！
E2S方向：第2辆车，通行！
W2N方向：第2辆车，通行！
E2S灯：变红
S2N灯：变绿
------------------------
当前全部交通灯状态：
S2N-GREEN, S2W-RED, E2W-RED, E2S-RED,
N2S-GREEN, N2E-RED, W2E-RED, W2N-RED,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
N2S方向：第2辆车，通行！
S2N灯：变红
S2W灯：变绿
------------------------
当前全部交通灯状态：
S2N-RED, S2W-GREEN, E2W-RED, E2S-RED,
N2S-RED, N2E-GREEN, W2E-RED, W2N-RED,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
S2W灯：变红
E2W灯：变绿
------------------------
当前全部交通灯状态：
S2N-RED, S2W-RED, E2W-GREEN, E2S-RED,
N2S-RED, N2E-RED, W2E-GREEN, W2N-RED,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
E2W灯：变红
E2S灯：变绿
------------------------
当前全部交通灯状态：
S2N-RED, S2W-RED, E2W-RED, E2S-GREEN,
N2S-RED, N2E-RED, W2E-RED, W2N-GREEN,
S2E-GREEN, E2N-GREEN, N2W-GREEN, W2S-GREEN.
------------------------
… …

复制代码

如果嫌每条路上1000辆车太少，可以像你代码中那样修改为10000就是。
至于统计每个小时的车流量以及清空集合释放资源，确实属于升级；
但对这个问题的理解和建模感觉帮助不大。

帐号		自动登录	找回密码
密码			加入黑马

升级交通灯问题(可以循环模拟的车辆的来回)

评分

3 个回复

评分