问题:当创建 Road对象时，构造函数中还有线程还没执行完呢，12个对象就创立了，根本没走线程代码，然后执行        new LampController();然后才执行Road类中的线程，总之线程在构造函数中就看不懂了，不知道怎么执行顺序了，我认为new Road(directions[0]);要把构造函数里的所有代码执行完才可以new Road(directions[1])，Road类的构造方法中的两个线程不懂怎么执行的
package com.isoftstone.interview.traffic;
public class MainClass {
        /**
         * @param args
         */
        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);
                }
                /*产生整个交通灯系统*/               
                new LampController();
        }
}





public class Road {
        private List<String> vechicles = new ArrayList<String>();

        private String name =null;
        public Road(String name){
                this.name = name;

                //模拟车辆不断随机上路的过程               
                ExecutorService pool = Executors.newSingleThreadExecutor();
                pool.execute(new Runnable(){
                        public void run(){
                                for(int i=1;i<1000;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);

        }
}

项目要求：每个路口1到10之间会随机出现一辆车，也就是说，某条路上的车可能会在1-10秒不等的时间内增加一辆车。
for(int i=1;i<1000;i++){
                                        try {
                                                Thread.sleep((new Random().nextInt(10) + 1) * 1000);//线程一定会在1到十秒内执行到下面一行语句(往路上添加一辆车)
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                        vechicles.add(Road.this.name + "_" + i);//往记录该路上车辆的车的数量的容器增一辆车
                                }                                
                        }
那使用构造函数穿件对象是不是要等待线程运行完才能创建成功？这一句打错字了吗？看不是很明

谢洋 发表于 2013-3-22 23:47
项目要求：每个路口1到10之间会随机出现一辆车，也就是说，某条路上的车可能会在1-10秒不等的时间内增加一 ...

我的问题是这线程上面时候结束，肯定不是睡那么久

谢洋 发表于 2013-3-22 23:47
项目要求：每个路口1到10之间会随机出现一辆车，也就是说，某条路上的车可能会在1-10秒不等的时间内增加一 ...

改了创建

夏晓彤 发表于 2013-3-22 23:58
改了创建

看来我是答非所问了，这个真搞不明

想不明
可这样子做一个试验：
1、让一个子类继成Road顺便把run里面的内容改为打印信息,且让也它睡一会，
2、在子类的构造中调用父类的构造，并在其后打印信息，看一下打印顺序是怎么的的
经测试，不用等线程执行完才对完成对象的创建

谢洋 发表于 2013-3-23 00:43
想不明
可这样子做一个试验：
1、让一个子类继成Road顺便把run里面的内容改为打印信息,且让也它睡一会，

我把问题修改明确了，帮我解解下惑吧哥们

下面代代码是通过创建子类对象时，查看子类的构造是否等父类中线程执行才被执行的：
当子类构造调用父类构造后，父类中的线程对象一旦被建立就会被启动;这时虽然线程对象被执行，但子类对象还没有被完全建立
也就是说对象只有建立后才能被使用的（如线程对象）;不知怎么才表达得清楚，你查看代码的运行结果应该会明白的

1. 
   
2. <P>package test;</P>
   
3. <P>import java.util.ArrayList;
   
4. import java.util.List;
   
5. import java.util.concurrent.ExecutorService;
   
6. import java.util.concurrent.Executors;
   
7. import java.util.concurrent.ScheduledExecutorService;
   
8. import java.util.concurrent.TimeUnit;</P>
   
9. <P>public class MutipThread {</P>
   
10. <P> /**
    
11.   * @param args
    
12.   */
    
13. public static void main(String[] args) {
    
14.   new ZiRoad("zizi");</P>
    
15. <P> }</P>
    
16. <P>}
    
17. class Road {
    
18.     private List<String> vechicles = new ArrayList<String>();
    
19.    
    
20.     private String name =null;
    
21.     public Road(String name){
    
22.             this.name = name;
    
23.             
    
24.             //模拟车辆不断随机上路的过程               
    
25.             ExecutorService pool = Executors.newSingleThreadExecutor();
    
26.             pool.execute(new Runnable(){
    
27.                     public void run(){
    
28.                             for(int i=1;i<1000;i++){
    
29.                              try {
    
30.                               System.out.println("第------段来了");
    
31.                               Thread.sleep(2000);
    
32.                               System.out.println("第=====段来了");
    
33.          Thread.sleep(2000);
    
34.         } catch (InterruptedException e) {
    
35.          // TODO Auto-generated catch block
    
36.          e.printStackTrace();
    
37.         }
    
38.                             }                                
    
39.                     }
    
40.                     
    
41.             });
    
42.             
    
43.             //每隔一秒检查对应的灯是否为绿，是则放行一辆车               
    
44.             ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
    
45.             timer.scheduleAtFixedRate(
    
46.                             new Runnable(){
    
47.                                     public void run(){
    
48.                                      while(true){
    
49.                                       
    
50.                                       System.out.println("第二段来了");
    
51.                  try {
    
52.             Thread.sleep(1000);
    
53.            } catch (InterruptedException e) {
    
54.             // TODO Auto-generated catch block
    
55.             e.printStackTrace();
    
56.            }</P>
    
57. <P>                                     }                       
    
58.                                     }
    
59.                             },
    
60.                             1,
    
61.                             1,
    
62.                             TimeUnit.SECONDS);
    
63.             
    
64.     }
    
65. }</P>
    
66. <P>class ZiRoad extends Road{</P>
    
67. <P> public ZiRoad(String name) {
    
68.   super(name);
    
69.   System.out.println("子子子子构造");//看看是否等线程执行完才执行到这
    
70. }
    
71. }
    
72. </P>

复制代码