如何使“主线程”等待“子线程”执行结束后再继续执行？

[wugui414]

public static void main(String[] args){
    System.out.println("start");
    for (int i = 0 ; i < 10; i ++){
                Thread t = new SelectThread(sql,i*interval+1,interval, result);
                t.start();
                t.join();
    }
    System.out.println("end");
}

以上是我的代码,这样可以吗？

[windyfzz]

我觉得设置一个标记比较好 boolean flag=false;
例如一个子线程：
class childThread extends Thread
{
.....
while(true)
{
public void run()
{
.......
flag=true//当子线程运行完成后标记设为true
}
}
}

然后根据该标记的值判断子线程是否执行。

你可以这样写:
....
childThread ct=new childThread();

ct.start();

if(ct.flag == false)
{
Thread.sleep(10);[color=#00FF00]当子线程没有执行完毕，就让主线程等待}[/color].....

如果不设置标记判断 而是直接让主线程 Thread.sleep(xxx)睡眠是不合理的。
原因是:
由于主线程和子线程是并发运行的 睡眠的时间不好控制 如果时间太短 可能子线程没有运行完主线程就又开始运行了。如果时间太长 影响程序的执行效率 所以这个时间是不好控制的。
上面有的直接 Thread.sleep(100);完全是想当然的想法。 直接这样写有可能是会出错的 你可以试下。
所以我觉得还是设置一个标记比较好。

[阳明 to life]

[Quote=引用 2 楼 wugui414 的回复:]

引用 1 楼 zhouyuqwert 的回复:

那你何必开线程

怎么了？讲讲，我这样做是不是使子线程逐个执行了？
[/Quote]
你想让主线程等待你那个子线程执行完跟你直接调用函数有区别？ 所以我说没必要开线程了

[皮皮]

是啊，同意楼上

[daijope]

t.start()后面加一个sleep(100),就可以先执行子线程了。

[daijope]

应该是Thread.sleep(100);

[阳明 to life]

[Quote=引用 7 楼 daijope 的回复:]

应该是Thread.sleep(100);
[/Quote]
别人需求的是等待子线程执行完，而不是子线程先执行

[冰思雨]

楼主的代码，能够完成楼主的意图。
1.主线程开启。
2.逐个创建10个线程，并且，10个线程一次运行。
3.主线程，等待前一个子线程运行完毕后，再进入下一个循环，创建线程。
4.最后，主线程结束。


楼主的代码，应该主要是测试，主线程，等待子线程的运行结束。
而并非测试，多线程的并发。

需求不同，观察事物的角度，自然就会不同。

[walkman_22]

设置子线程优先级高些

[ChDw]

你这样做没有什么意义，实际上是单线程，我觉得你应该是想10个线程同时启动，但是所有线程结束以后再继续主线程


那应该是

System.out.println("start");
List<Thread> list = new ArrayList<Thread>();
for (int i = 0 ; i < 10; i ++){
    Thread t = new SelectThread(sql,i*interval+1,interval, result);
    list.add(t);
    t.start();
}
for(Thread t : list)
    t.join();
System.out.println("end");

[wula0010]

我是这样来处理的：

for (int i = 0; i < threads; i++) {
    MyThread myThread = new MyThread(i);
    theThreads[i] = new Thread(myThread);
    theThreads[i].start();
}

boolean isRuning = true;
while (isRuning) {
    for (Integer i = 0; i < threads; i++) {
        if (theThreads[i].isAlive()) {
            isRuning = true;
            break;
        }
        isRuning = false;
    }
}

[shine333]

[Quote=引用 11 楼 wula0010 的回复:]

我是这样来处理的：
Java code

for (int i = 0; i < threads; i++) {
MyThread myThread = new MyThread(i);
theThreads[i] = new Thread(myThread);
theThreads[i].start();
}

boolean isRuning = true;
wh……
[/Quote]
代价太大（至少主线程sleep一下再判断吧），不如用join

[Mybeautiful]

同意 chdW,楼主应该是这个意思，让10个线程可以并行执行，但是"主"线程等那10个线程结束后继续，

System.out.println("start");
List<Thread> list = new ArrayList<Thread>();
for (int i = 0 ; i < 10; i ++){
    Thread t = new SelectThread(sql,i*interval+1,interval, result);
    list.add(t);
    t.start();
}
for(Thread t : list)
    t.join();
System.out.println("end");

[shine333]

不过个人不是很喜欢join

[syoumei]

学习了

[wugui414]

[Quote=引用 10 楼 chdw 的回复:]

你这样做没有什么意义，实际上是单线程，我觉得你应该是想10个线程同时启动，但是所有线程结束以后再继续主线程


那应该是

Java code
System.out.println("start");
List<Thread> list = new ArrayList<Thread>();
for (int i = 0 ; i < 10; i ++){
Thread t = ……
[/Quote]

恩，确实是子线程并行，主线程等待，但是我想知道这样的原理，跟我写的有什么区别？

[shine333]

当然有区别了
你的代码等价于
Thread t0 = new SelectThread(sql,0*interval+1,interval, result);
t0.start();
t0.join(); // main一直等t0，直到t0结束，后面的代码才能执行

Thread t1 = new SelectThread(sql,1*interval+1,interval, result);
t1.start();
t1.join(); // main一直等t1，直到t1结束，后面的代码才能执行
...

这个就是单线程

[shine333]

他人的代码，是统统start，10个工作线程都已经上路了，然后再去join，依次等t0，等t1，等t2...

而你是依次“启动t0,等t0”，“启动t1,等t1”

[wugui414]

[Quote=引用 19 楼 shine333 的回复:]

他人的代码，是统统start，10个工作线程都已经上路了，然后再去join，依次等t0，等t1，等t2...

而你是依次“启动t0,等t0”，“启动t1,等t1”
[/Quote]

受教

[wugui414]

[Quote=引用 21 楼 windyfzz 的回复:]

我觉得设置一个标记比较好 boolean flag=false;
例如一个子线程：
class childThread extends Thread
{
.....
while(true)
{
public void run()
{
.......
flag=true//当子线程运行完成后标记设为true
……
[/Quote]

想到这种方法了，但是怕不高效

[小樊]

主线成启动以后，执行子线程的时候设置优先级