我对 Java 线程中使用的 join() 方法感到困惑。在以下代码中:

// Using join() to wait for threads to finish.
class NewThread implements Runnable {

    String name; // name of thread
    Thread t;

    NewThread(String threadname) {
        name = threadname;
        t = new Thread(this, name);
        System.out.println("New thread: " + t);
        t.start(); // Start the thread
    }
// This is the entry point for thread.

    public void run() {
        try {
            for (int i = 5; i > 0; i--) {
                System.out.println(name + ": " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println(name + " interrupted.");
        }
        System.out.println(name + " exiting.");
    }
}

class DemoJoin {

    public static void main(String args[]) {
        NewThread ob1 = new NewThread("One");
        NewThread ob2 = new NewThread("Two");
        NewThread ob3 = new NewThread("Three");
        System.out.println("Thread One is alive: "
                + ob1.t.isAlive());
        System.out.println("Thread Two is alive: "
                + ob2.t.isAlive());
        System.out.println("Thread Three is alive: "
                + ob3.t.isAlive());
// wait for threads to finish
        try {
            System.out.println("Waiting for threads to finish.");
            ob1.t.join();
            ob2.t.join();
            ob3.t.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread Interrupted");
        }
        System.out.println("Thread One is alive: "
                + ob1.t.isAlive());
        System.out.println("Thread Two is alive: "
                + ob2.t.isAlive());
        System.out.println("Thread Three is alive: "
                + ob3.t.isAlive());
        System.out.println("Main thread exiting.");
    }
}

此程序的示例输出如下所示:

New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
Thread One is alive: true
Thread Two is alive: true
Thread Three is alive: true
Waiting for threads to finish.
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Two: 2
Three: 2
One: 1
Two: 1
Three: 1
Two exiting.
Three exiting.
One exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
Main thread Exiting

在上面的代码中:

1. 我无法理解程序的执行流程，当创建 ob1 时，会调用构造函数，其中 t.start() 已写入，但 run() 方法仍未执行，而 main() 方法继续执行。那么为什么会这样呢？

2. join() 方法用于等待直到调用它的线程没有终止，但是在输出中我们看到线程的备用输出为什么？？

如果 join 的使用是这样的，那么 synchronized 的使用是什么？？

我知道我在这里遗漏了一个基本概念，但我无法弄清楚，所以请帮忙。

最佳答案

你必须明白，线程的调度是由线程调度器控制的，所以一般情况下你不能保证线程的执行顺序。

但是，您可以使用 join() 等待线程完成其工作。

例如，在你的情况下

ob1.t.join();

在线程 t 完成运行之前，该语句不会返回。

试试这个，

class Demo {
   Thread t = new Thread(
                 new Runnable() {
                     public void run () {
                         //do something
                     }
                  }
    );
    Thread t1 = new Thread(
                 new Runnable() {
                     public void run () {
                         //do something
                     }
                  }
    );
    t.start(); // Line 15
    t.join();  // Line 16
    t1.start();
}

在上面的例子中，你的主线程正在执行。当它遇到第 15 行时，线程 t 在线程调度程序中可用。主线程一到第 16 行，就会等待线程 t 完成。

注意 t.join 没有对线程 t 或线程 t1 做任何事情。它只影响调用它的线程(即 main() 线程)。

已编辑:

t.join(); 需要在 try block 内，因为它 throw InterruptedException 异常, 否则编译时会报错。所以，应该是:

try{
    t.join();
}catch(InterruptedException e){
    // ...
}

关于Java多线程概念和join()方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18479771/