java - 如何让主线持续？

Question

如何让主进程最后结束？

例如，我编写了一些代码，它创建了一个线程:Test，该线程创建了另外三个线程 - Test2，但 main 在 Test 之前完成> 开始。

public class Test implements Runnable{
    String url;
    Thread mThread;

    public Test(String url) {
        this.url = url;        
    }

    public void start(){
       this.mThread = new Thread(this);
       this.mThread.start();
    }

     @Override
    public void run() {
        System.out.println("TEST STARTED!");
        Test2 wclw[] = new Test2[3];

            for (int i = 0; i < wclw.length; i++) {
                wclw[i] = new Test2(url, i + 1);
                wclw[i].start();
            }
    }

    public static void main(String[] args) throws IOException {
        System.out.println("MAin STARTED!");
        (new Test("qwerty")).start();

        System.out.println("MAIN FINISHED");
    }
}

class Test2 implements Runnable{
    String url;
    int threadNum;
    Thread mThread;

    public Test2(String url, int threadNum) {
        this.url = url;
    }

    public void start(){
        this.mThread = new Thread(this);
        this.mThread.start();
    }   

    @Override
    public void run() {
         System.out.println("TEST2 STARTED!");   
         for (int i = 0; i < 2; i++) {
            System.out.println(url);
        }
    }
}

输出:

MAin STARTED! 
MAIN FINISHED 
TEST STARTED!
qwerty
TEST2 STARTED!
TEST2 STARTED!
qwerty
qwerty 
TEST2 STARTED!
qwerty 
qwerty
qwerty

Answer 1

How to make the main processs ended last?

我假设您指的是主线程。您需要使用thread.join()。您的主线程应该与其生成的线程连接，子线程也需要与其生成的线程连接。 thread.join() 等待线程完成后再继续。

Test test = new Test("qwerty");
// start the test thread running in the background
test.start();
// do other stuff on the main thread
...
// wait for the test thread to finish
test.mThread.join();

在测试线程中您应该执行以下操作:

// start other threads
for (int i = 0; i < wclw.length; i++) {
    wclw[i] = new Test2(url, i + 1);
    wclw[i].start();
}
// do other stuff in the test thread if necessary
...
// come back and wait for them all to finish
for (int i = 0; i < wclw.length; i++) {
    wclw[i].mthread.join();
}

因此子线程将等待它生成的每个线程完成，然后它就会完成。主线程会等待子线程完成，然后最后完成。

仅供引用:主线程在子线程之前完成不是问题。子线程不是守护线程，因此 JVM 将在 JVM 关闭之前等待它们完成。