第五章 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 线程连接示例的全部内容。


原文链接:https://codingdict.com/