2. 程式人生 > >java多執行緒中的join方法詳解

java多執行緒中的join方法詳解

阿新 • • 發佈：2019-02-02

 方法Join是幹啥用的？ 簡單回答，同步，如何同步？ 怎麼實現的？ 下面將逐個回答。

    自從接觸Java多執行緒，一直對Join理解不了。JDK是這樣說的：join public final void join（long millis）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.大家能理解嗎？ 字面意思是等待一段時間直到這個執行緒死亡，我的疑問是那個執行緒，是它本身的執行緒還是呼叫它的執行緒的，上程式碼： 

package concurrentstudy;
/**
 *
 * @author vma
 */
public class JoinTest {
    public static void main(String[] args) {
        Thread t = new Thread(new RunnableImpl());
        t.start();
        try {
            t.join(1000);
            System.out.println("joinFinish");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
     
        }
    }
}
class RunnableImpl implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("Begin sleep");
            Thread.sleep(1000);
           System.out.println("End sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

結果是：
Begin sleep
End sleep
joinFinish
明白了吧，當main執行緒呼叫t.join時，main執行緒等待t執行緒，等待時間是1000，如果t執行緒Sleep 2000呢
 public void run() {
        try {
            System.out.println("Begin sleep");
            // Thread.sleep(1000);
            Thread.sleep(2000);
           System.out.println("End sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
結果是：
Begin sleep
joinFinish
End sleep
也就是說main執行緒只等1000毫秒，不管T什麼時候結束，如果是t.join()呢， 看程式碼：  
 public final void join() throws InterruptedException {
    join(0);
    }
    就是說如果是t.join() = t.join(0) 0　JDK這樣說的 A timeout of 0

means to wait forever 字面意思是永遠等待，是這樣嗎？
    其實是等到t結束後。
    這個是怎麼實現的嗎？ 看JDK程式碼：

    /**
     * Waits at most <code>millis</code> milliseconds for this thread to 
     * die. A timeout of <code>0</code> means to wait forever. 
     *
     * @param      millis   the time to wait in milliseconds.
     * @exception  InterruptedException if any thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     */
    public final synchronized void join(long millis) 
    throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
        wait(0);
        }
    } else {
        while (isAlive()) {
        long delay = millis - now;
        if (delay <= 0) {
            break;
        }
        wait(delay);
        now = System.currentTimeMillis() - base;
        }
    }
    }

    其實Join方法實現是通過wait（小提示：Object 提供的方法）。 當main執行緒呼叫t.join時候，main執行緒會獲得執行緒物件t的鎖（wait 意味著拿到該物件的鎖),呼叫該物件的wait(等待時間)，直到該物件喚醒main執行緒，比如退出後。



    這就意味著main 執行緒呼叫t.join時，必須能夠拿到執行緒t物件的鎖，如果拿不到它是無法wait的，剛開的例子t.join(1000)不是說明了main執行緒等待1 秒，如果在它等待之前，其他執行緒獲取了t物件的鎖，它等待時間可不就是1毫秒了。上程式碼介紹：

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package concurrentstudy;
/**
 *
 * @author vma
 */
public class JoinTest {
    public static void main(String[] args) {
        Thread t = new Thread(new RunnableImpl());
       new ThreadTest(t).start();
        t.start();
        try {
            t.join();
            System.out.println("joinFinish");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
     
        }
    }
}
class ThreadTest extends Thread {

    Thread thread;

    public ThreadTest(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        holdThreadLock();
    }

    public void holdThreadLock() {
        synchronized (thread) {
            System.out.println("getObjectLock");
            try {
                Thread.sleep(9000);

            } catch (InterruptedException ex) {
             ex.printStackTrace();
            }
            System.out.println("ReleaseObjectLock");
        }

    }
}

class RunnableImpl implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("Begin sleep");
            Thread.sleep(2000);
           System.out.println("End sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

    在main方法中 通過new ThreadTest(t).start();例項化ThreadTest 執行緒物件， 它在holdThreadLock()方法中，通過 synchronized (thread)，獲取執行緒物件t的鎖，並Sleep（9000）後釋放，這就意味著，即使
main方法t.join(1000),等待一秒鐘，它必須等待ThreadTest 執行緒釋放t鎖後才能進入wait方法中，它實際等待時間是9000+1000 MS
執行結果是：
getObjectLock
Begin sleep
End sleep
ReleaseObjectLock
joinFinish

轉自：http://java.chinaitlab.com/JDK/760879.html

ps：

二、為什麼要用join()方法

主執行緒生成並起動了子執行緒，而子執行緒裡要進行大量的耗時的運算(這裡可以借鑑下執行緒的作用)，當主執行緒處理完其他的事務後，需要用到子執行緒的處理結果，這個時候就要用到join();方法了。

三、join方法的作用

在網上看到有人說“將兩個執行緒合併”。這樣解釋我覺得理解起來還更麻煩。不如就借鑑下API裡的說法：

“等待該執行緒終止。”

解釋一下，是主執行緒(我在“一”裡已經命名過了)等待子執行緒的終止。也就是在子執行緒呼叫了join()方法後面的程式碼，只有等到子執行緒結束了才能執行。(Waits for this thread to die.)

四、用例項來理解

寫一個簡單的例子來看一下join()的用法，一共三個類：

1.CustomThread 類

2. CustomThread1類

3. JoinTestDemo 類，main方法所在的類。

程式碼1：

  1. package wxhx.csdn2;  
  2. /** 
  3.  *  
  4.  * @author bzwm 
  5.  * 
  6.  */  
  7. class CustomThread1 extends Thread {  
  8.     public CustomThread1() {  
  9.         super("[CustomThread1] Thread");  
  10.     };  
  11.     public void run() {  
  12.         String threadName = Thread.currentThread().getName();  
  13.         System.out.println(threadName + " start.");  
  14.         try {  
  15.             for (int i = 0; i < 5; i++) {  
  16.                 System.out.println(threadName + " loop at " + i);  
  17.                 Thread.sleep(1000);  
  18.             }  
  19.             System.out.println(threadName + " end.");  
  20.         } catch (Exception e) {  
  21.             System.out.println("Exception from " + threadName + ".run");  
  22.         }  
  23.     }  
  24. }  
  25. class CustomThread extends Thread {  
  26.     CustomThread1 t1;  
  27.     public CustomThread(CustomThread1 t1) {  
  28.         super("[CustomThread] Thread");  
  29.         this.t1 = t1;  
  30.     }  
  31.     public void run() {  
  32.         String threadName = Thread.currentThread().getName();  
  33.         System.out.println(threadName + " start.");  
  34.         try {  
  35.             t1.join();  
  36.             System.out.println(threadName + " end.");  
  37.         } catch (Exception e) {  
  38.             System.out.println("Exception from " + threadName + ".run");  
  39.         }  
  40.     }  
  41. }  
  42. public class JoinTestDemo {  
  43.     public static void main(String[] args) {  
  44.         String threadName = Thread.currentThread().getName();  
  45.         System.out.println(threadName + " start.");  
  46.         CustomThread1 t1 = new CustomThread1();  
  47.         CustomThread t = new CustomThread(t1);  
  48.         try {  
  49.             t1.start();  
  50.             Thread.sleep(2000);  
  51.             t.start();  
  52.             t.join();//在程式碼2裡，將此處注釋掉  
  53.         } catch (Exception e) {  
  54.             System.out.println("Exception from main");  
  55.         }  
  56.         System.out.println(threadName + " end!");  
  57.     }  
  58. }  

列印結果：

main start.//main方法所在的執行緒起動，但沒有馬上結束，因為呼叫t.join();，所以要等到t結束了，此執行緒才能向下執行。

[CustomThread1] Thread start.//執行緒CustomThread1起動

[CustomThread1] Thread loop at 0//執行緒CustomThread1執行

[CustomThread1] Thread loop at 1//執行緒CustomThread1執行

[CustomThread] Thread start.//執行緒CustomThread起動，但沒有馬上結束，因為呼叫t1.join();，所以要等到t1結束了，此執行緒才能向下執行。

[CustomThread1] Thread loop at 2//執行緒CustomThread1繼續執行

[CustomThread1] Thread loop at 3//執行緒CustomThread1繼續執行

[CustomThread1] Thread loop at 4//執行緒CustomThread1繼續執行

[CustomThread1] Thread end. //執行緒CustomThread1結束了

[CustomThread] Thread end.// 執行緒CustomThread在t1.join();阻塞處起動，向下繼續執行的結果

main end!//執行緒CustomThread結束，此執行緒在t.join();阻塞處起動，向下繼續執行的結果。

修改一下程式碼，得到程式碼2：(這裡只寫出修改的部分)

  1. public class JoinTestDemo {  
  2.     public static void main(String[] args) {  
  3.         String threadName = Thread.currentThread().getName();  
  4.         System.out.println(threadName + " start.");  
  5.         CustomThread1 t1 = new CustomThread1();  
  6.         CustomThread t = new CustomThread(t1);  
  7.         try {  
  8.             t1.start();  
  9.             Thread.sleep(2000);  
  10.             t.start();  
  11. //          t.join();//在程式碼2裡，將此處注釋掉  
  12.         } catch (Exception e) {  
  13.             System.out.println("Exception from main");  
  14.         }  
  15.         System.out.println(threadName + " end!");  
  16.     }  
  17. }  

列印結果：

main start. // main方法所在的執行緒起動，但沒有馬上結束，這裡並不是因為join方法，而是因為Thread.sleep(2000);

[CustomThread1] Thread start. //執行緒CustomThread1起動

[CustomThread1] Thread loop at 0//執行緒CustomThread1執行

[CustomThread1] Thread loop at 1//執行緒CustomThread1執行

main end!// Thread.sleep(2000);結束，雖然線上程CustomThread執行了t1.join();，但這並不會影響到其他執行緒(這裡main方法所在的執行緒)。

[CustomThread] Thread start. //執行緒CustomThread起動，但沒有馬上結束，因為呼叫t1.join();，所以要等到t1結束了，此執行緒才能向下執行。

[CustomThread1] Thread loop at 2//執行緒CustomThread1繼續執行

[CustomThread1] Thread loop at 3//執行緒CustomThread1繼續執行

[CustomThread1] Thread loop at 4//執行緒CustomThread1繼續執行

[CustomThread1] Thread end. //執行緒CustomThread1結束了

[CustomThread] Thread end. // 執行緒CustomThread在t1.join();阻塞處起動，向下繼續執行的結果

五、從原始碼看join()方法

在CustomThread的run方法裡，執行了t1.join();，進入看一下它的JDK原始碼：

  1. public final void join() throws InterruptedException {  
  2. n(0);  
  3. }  

然後進入join(0)方法：

  1.    /** 
  2.     * Waits at most <code>millis</code> milliseconds for this thread to  
  3.     * die. A timeout of <code>0</code> means to wait forever. //注意這句 
  4.     * 
  5.     * @param      millis   the time to wait in milliseconds. 
  6.     * @exception  InterruptedException if another thread has interrupted 
  7.     *             the current thread.  The <i>interrupted status</i> of the 
  8.     *             current thread is cleared when this exception is thrown. 
  9.     */  
  10.    public final synchronized void join(long millis) //引數millis為0.  
  11.    throws InterruptedException {  
  12. long base = System.currentTimeMillis();  
  13. long now = 0;  
  14. if (millis < 0) {  
  15.            throw new IllegalArgumentException("timeout value is negative");  
  16. }  
  17. if (millis == 0) {//進入這個分支  
  18.     while (isAlive()) {//判斷本執行緒是否為活動的。這裡的本執行緒就是t1.  
  19.     wait(0);//阻塞  
  20.     }  
  21. } else {  
  22.     while (isAlive()) {  
  23.     long delay = millis - now;  
  24.     if (delay <= 0) {  
  25.         break;  
  26.     }  
  27.     wait(delay);  
  28.     now = System.currentTimeMillis() - base;  
  29.     }  
  30. }  
  31.    }  

單純從程式碼上看，如果執行緒被生成了，但還未被起動，呼叫它的join()方法是沒有作用的。將直接繼續向下執行，這裡就不寫程式碼驗證了。

相關推薦

白話理解java多執行緒中join()方法

join字面意思是加入,我理解為插隊. 舉例:媽媽在炒菜,發現沒喲醬油了,讓兒子去打醬油,兒子打完醬油,媽媽炒完菜,全家一起吃 package cn.yh.thread01; /** * *

JAVA多執行緒中join()方法的詳細分析

雖然關於討論執行緒join()方法的部落格已經非常極其特別多了，但是前幾天我有一個困惑卻沒有能夠得到詳細解釋，就是當系統中正在執行多個執行緒時，join()到底是暫停了哪些執行緒，大部分部落格給的例子看起來都像是t.join()方法會使所有執行緒都暫停並等待t的執行完畢。當然

Java多執行緒中join方法的理解

[CustomThread1] Thread start.      //執行緒CustomThread1起動 [CustomThread1] Thread loop at 0   //執行緒CustomThread1執行 [CustomThread1] Thread loop at 1   //執行緒Cu

Java—Java多執行緒中join方法的理解

[CustomThread1] Thread start.      //執行緒CustomThread1起動 [CustomThread1] Thread loop at 0   //執行緒CustomThread1執行 [CustomThread1] Thread loop at 1   //執行緒Cu

Java多執行緒中join方法的實現

方法join的作用是使所屬的執行緒物件t正常執行run()方法中的任務，而使當前執行緒z進行阻塞，等待t銷燬後再繼續執行z後面的程式碼。 下面貼出join方法的原始碼： public final synchronized void join(long millis)

Java多執行緒中join、yield、sleep方法詳解

在Java多執行緒程式設計中，Thread類是其中一個核心和關鍵的角色。因此，對該類中一些基礎常用方法的理解和熟練使用是開發多執行緒程式碼的基礎。本篇主要總結一下Thread中常用的一些靜態方法的含義及程式碼中的使用。 sleep方法 原始碼如下： /** * Causes the curr

Java多執行緒之join()方法

概要 本章，會對Thread中join()方法進行介紹。涉及到的內容包括： 1. join()介紹 2. join()原始碼分析(基於JDK1.7.0_40) 3. join()示例 來源：http://www.cnblogs.com/skywang12345/p/34792

白話理解java多執行緒之join()方法

join字面意思是加入,我理解為插隊. 舉例:媽媽在炒菜,發現沒喲醬油了,讓兒子去打醬油,兒子打完醬油,媽媽炒完菜,全家一起吃 package cn.yh.thread01; /** * * 打醬油的例子 */ public class Demo03 { public stat

Java多執行緒中所有方法的解析

一、run()和start() 　　這兩個方法應該都比較熟悉，把需要並行處理的程式碼放在run()方法中，start()方法啟動執行緒將自動呼叫 run()方法，這是由Java的記憶體機制規定的。並且run()方法必須是public訪問許可權，返回值型別為void。 　　二

Java多執行緒Condition介面原理詳解

Condition介面提供了類似Object的監視器方法，與Lock配合可以實現等待/通知模式，但是這兩者在使用方式以及功能特性上還是有差別的 Condition介面詳解 Condition定義了等待/通知兩種型別的方法，當前執行緒呼叫這些方法時，需要提前獲

Java多執行緒同步和非同步詳解

1. 多執行緒併發時，多個執行緒同時請求同一資源，必然導致此資源的資料不安全。 2. 執行緒池 在WEB服務中，對於web伺服器的響應速度必須儘可能的快，這就容不得在使用者提交請求按鈕後，再建立執行緒提供服務。為了減少使用者的等待時間，執行緒必須預先建立，放線上程池中，執行

入坑JAVA多執行緒併發(八）詳解ThreadLocal使用和原理

　　ThreadLocal是一個用於儲存多執行緒變數的類，它可以把執行緒與設定的值對應起來，因為它為變數在每個執行緒都建立了一個副本。訪問的時候每個執行緒只能訪問到自己的副本變數。 例項 看如下程式碼： public class Main {

JAVA多執行緒Thread VS Runnable詳解

要求 必備知識 本文要求基本瞭解JAVA程式設計知識。 開發環境 windows 7/EditPlus 演示地址 原始檔 程序與執行緒 程序是程式在處理機中的一次執行。一個程序既包括其所要執行的指令，也包括了執行指令所需的系統資源，不同程序所

Java 多執行緒之synchronized關鍵字詳解

package com.example; /** * Created by 晁東洋 on 2017/5/27. */ public class MyThreadClass { public static void main(String args[]){ Exampletest

java多執行緒與併發程式設計詳解

一、多執行緒1、作業系統有兩個容易混淆的概念，程序和執行緒。程序：一個計算機程式的執行例項，包含了需要執行的指令；有自己的獨立地址空間，包含程式內容和資料；不同程序的地址空間是互相隔離的；程序擁有各種資源和狀態資訊，包括開啟的檔案、子程序和訊號處理。執行緒：表示程式的執行流程

java多執行緒中的join方法詳解

 方法Join是幹啥用的？ 簡單回答，同步，如何同步？ 怎麼實現的？ 下面將逐個回答。     自從接觸Java多執行緒，一直對Join理解不了。JDK是這樣說的：join public final void join（long millis）throws InterruptedException Wait

java多執行緒中關於join方法的使用

Thread的非靜態方法join()讓一個執行緒B“加入”到另外一個執行緒A的尾部。在A執行完畢之前，B不能工作。例如：         Thread t = new MyThread();         t.start();         t.join(); 另外，j

java多執行緒中對於join方法的理解

對於多執行緒的join方法一直理解得很模糊，大致看了一些資料，JDK是這樣說的：join public final void join （long millis ）throws InterruptedException Waits at most millis

Java多執行緒中，Join和Interrupt（）方法的使用

更多詳細的解答請轉至：http://my.oschina.net/summerpxy/blog/198457；http://uule.iteye.com/blog/1101994；（比如有一個執行緒t.當在Main執行緒中呼叫t.join()的時候，那麼Main執行緒必須拿

Java多執行緒中注入Spring的Bean-使用靜態方法直接取的容器中的spring物件

目前認為比較好的解決方案。 1，工具類 public class SpringApplicationContextHolder implements ApplicationContextAware { private static ApplicationContext context