第五章Java线程连接示例|

在这篇文章中，我们将了解 Java 线程连接方法。

Thread 类的join()方法可用于停止线程的当前执行，直到它加入的线程完成其任务。所以基本上，它等待调用 join 方法的线程死亡。例如： 这里当你调用 时t1.join()，主线程会等待 t1 完成它的启动，然后再恢复它的执行。

// Main thread execution
Thread t1=new Thread(mr,"Thread 1");t1.start();
// lets waits for t1 to die
try {
t1.join();
} catch (InterruptedException e) {

连接方法的变体

连接方法有三种变体

调用 join 方法的线程死亡。

public final void join(long millis) 抛出 InterruptedException

在线程上调用此方法时，它会等待以下任一情况：

• 调用 join 方法的线程死亡。
• 指定毫秒

public final void join(long millis,int nanos) 抛出 InterruptedException

在线程上调用此方法时，它会等待以下任一情况：

• 调用 join 方法的线程死亡。
• 指定毫秒 + 纳秒

你知道吗？

如果调用 join 方法的线程已经终止或尚未启动，则 join 方法立即返回。

我们举一个简单的例子：

package org.arpit.java2blog;

public class MyRunnable implements Runnable {

    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " Start");
            // thread sleeps for 4 secs
            Thread.sleep(4000);
            System.out.println(Thread.currentThread().getName() + " end");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

创造ThreadExampleMain.java

package org.arpit.java2blog;

public class ThreadExampleMain {

    public static void main(String args[]) {

        System.out.println("Main thread execution starts");
        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr, "Thread 1");
        Thread t2 = new Thread(mr, "Thread 2");
        Thread t3 = new Thread(mr, "Thread 3");

        t1.start();
        // lets waits for t1 to die
        try {
            t1.join();
        } catch (InterruptedException e) {

            e.printStackTrace();
        }

        t2.start();
        try {
            // lets waits for 1 sec or t2 to die which ever occurs first
            t2.join(1000);

        } catch (InterruptedException e1) {

            e1.printStackTrace();
        }
        t3.start();

        // complete all threads before completing main thread
        try {
            t2.join();
            t3.join();

        } catch (InterruptedException e1) {

            e1.printStackTrace();
        }
        System.out.println("Main thread execution ends");
    }
}

当您运行上述程序时，您将获得以下输出。

Main thread execution starts
Thread 1 Start
Thread 1 end
Thread 2 Start
Thread 3 Start
Thread 2 end
Thread 3 end
Main thread execution ends

现在让我们分析输出。

1. 主线程执行开始。
2. Thread 1开始（线程 1 开始），正如我们所说t1.join()，它将等待t1死亡（线程 1 结束）。
3. Thread 2启动（线程 2 启动）并等待 1 秒或死亡，但由于我们在 run 方法中设置了 4 秒睡眠，它不会在 1 秒内死亡。所以主线程恢复并Thread 3开始（线程3开始）
4. 正如我们所说t2.join()和t3.join()。这 2 个线程将在退出主线程之前完成，因此线程 2 将结束（线程 2 结束），然后线程 3 将结束（线程 3 结束）。
5. 主线程执行结束。

Java 线程连接和同步

Java 线程连接方法保证发生在关系之前。

这意味着如果线程t1调用t2.join()，那么 t2 所做的所有更改对 t1 都是可见的。

这就是 Java 线程连接示例的全部内容。