2. 程式人生 > >顛覆我的Thread.join()

顛覆我的Thread.join()

阿新 • • 發佈：2017-09-15
hello 喚醒 [] row 之前 world! 優先 tar 對象

學而時習之，不亦說乎！

--《論語》

　　為什麽說是顛覆？

　　1)任何對象都可以作為鎖對象，鎖對象的行為都是一樣的嗎？之前我一直認為鎖對象的方法都是定義在Object類中，而所有類都是Object的子類，這些方法又都是native方法，那麽用哪個對象作為鎖對象又有什麽區別呢？

　　2）一個線程對象a在run()方法內部調用線程對象b的join()方法，那麽是將b線程加入，等到b線程執行完畢再執行a線程？那麽如果還有一個正在執行的c線程呢，線程c也會等待b執行完嗎？

代碼1：

package com.zby;

public class
 
 Application1 {

    public static void main(String[] args) {
        Thread prepare = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Hello,World!-----" + i);
                    try {
                        Thread.sleep(
 
500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        prepare.start();
        System.out.println("Hello,ZBY!");
    }

}

控制臺輸出：

Hello,ZBY!
Hello,World!-----0
Hello,World!-----1
Hello,World
 
!-----2
Hello,World!-----3
Hello,World!-----4

結果不難分析，主線程直接執行，而prepare線程雖然啟動了，但是執行沒那麽快，所以後執行了。但是我的prepare是進行準備工作的，我想讓prepare線程執行完畢後再執行主線程。

代碼2：

package com.zby;

public class Application2 {

    public static void main(String[] args) {
        Thread prepare = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Hello,World!-----" + i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        prepare.start();
        try {
            prepare.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Hello,ZBY!");
    }
}

控制臺輸出：

Hello,World!-----0
Hello,World!-----1
Hello,World!-----2
Hello,World!-----3
Hello,World!-----4
Hello,ZBY!

很小兒科，加了一個一行代碼：prepare.join()；要是之前我會理解成把prepare加入到主線程先執行，執行完才能執行其它線程。然而，非也。

Thread.join()源代碼：

    public final void join() throws InterruptedException {
        join(0);
    }
    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;
            }
        }
    }

這兒可以看出來，我們調用prepare.join()的時候發生了什麽：把prepare作為鎖對象，調用鎖對象的wait(0)方法，阻塞當前線程！也就是說，並不是把需要執行的線程加入進來讓他先執行，而是阻塞當前的線程！那麽，如果還有第三個線程也在執行，那麽prepare線程是不會一直執行，而是跟第三個線程搶CPU執行權。總結起來就是，其實就是阻塞了當前的線程，對於其他線程都是沒有影響的。感興趣可以加入第三個線程自己測試一下。

等價於代碼2的代碼3：

package com.zby;

public class Application3 {

    public static void main(String[] args) {
        Thread prepare = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Hello,World!-----" + i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        prepare.start();
        synchronized(prepare){
            try {
                prepare.wait(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Hello,ZBY!");
    }
}

控制臺輸出：

Hello,World!-----0
Hello,World!-----1
Hello,World!-----2
Hello,World!-----3
Hello,World!-----4
Hello,ZBY!

這兒就解決了第二個問題，join()方法其實不是把調用的線程加入進來優先執行，而是阻塞當前線程！

看完代碼3就有疑問了，prepare.wait(0);自然沒錯，阻塞住了主線程。但是並沒有任何地方調用notify或者notifyAll方法，線程不是應該一直阻塞麽，怎麽會在prepare執行完後繼續執行主線程代碼了？

這就是第一個問題了，普通對象當然是wait後必須等待notify喚醒才能繼續執行，但是Thread對象呢？具體的我也不知道，但是從這兒可以推論出，thread對象在執行完畢後，自動喚醒了！那麽到底是notify還是notifyAll呢？那麽，多啟動一個線程，並使用prepare對象作為鎖對象，調用wait方法。

代碼4：

package com.zby;

public class Application3 {

    public static void main(String[] args) {
        final Thread prepare = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Hello,World!-----" + i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        prepare.start();
        Thread ready = new Thread(new Runnable() {
            public void run() {
                synchronized (prepare) {
                    try {
                        prepare.wait(0);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println("Hello,Earth!-----" + i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        ready.start();
        synchronized (prepare) {
            try {
                prepare.wait(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Hello,ZBY!");
    }
}

控制臺輸出：

Hello,World!-----0
Hello,World!-----1
Hello,World!-----2
Hello,World!-----3
Hello,World!-----4
Hello,Earth!-----0
Hello,ZBY!
Hello,Earth!-----1
Hello,Earth!-----2
Hello,Earth!-----3
Hello,Earth!-----4
Hello,Earth!-----5
Hello,Earth!-----6
Hello,Earth!-----7
Hello,Earth!-----8
Hello,Earth!-----9

可以看出，在preare執行完之後，自動把ready和main線程都喚醒了！也就是說，使用Thread對象作為鎖對象，在Thread執行完成之後，會喚醒使用該對象作為鎖對象調用wait()休眠的線程。

總結：

1）使用線程的join方法，是將調用的線程對象作為鎖對象，阻塞當前線程，不影響其他線程的運行。

2）推論：Thread對象作為線程鎖對象，會在Thread對象執行完後，調用Thread對象的notifyAll方法。

顛覆我的Thread.join()

相關推薦

顛覆我的Thread.join()

hello 喚醒 [] row 之前 world! 優先 tar 對象 學而時習之，不亦說乎！ --《論語》 　　為什麽說是顛覆？ 　　1)任何對象都可以作為鎖對象，鎖對象的行為都是一樣的嗎？之前我一直認為鎖對象的方

Thread.Join() 方法

我們 logs threading start nbsp class tel finish 是不是 1. 什麽是 the calling thread? 2. 什麽是 a thread? 運行一個程序，即開啟了一個進程和至少一個線程，幹活的是線程而非

淺析Thread.join()

線程 edi xtend `` cond 通過 parent zed lar 概要 本文分為三部分對 hread.join() 進行分析： 1. join() 的示例和作用 2. join() 源碼分析 3. 對網上其他分析 join() 的文章提出疑問 1. join

淺析Java的Thread.join函數

比較 rgs 同步 自定義 測試 row exceptio throws illegal （一）join參數解析 join(): 即join(0)，主線程無限等待子進程結束，主線程方可執行。 join(long millis)：主線程需等待子進程*毫秒，主線程方可執行。 （

Python 多執行緒 thread join() 的作用

原文地址 在 Python 的多執行緒程式設計中，在例項程式碼中經常有 thread1.join()這樣的程式碼。那麼今天咱們用實際程式碼來解釋一下 join 函式的作用。   join的原理就是依次檢驗執行緒池中的執行緒是否結束，沒有結束就阻塞直到執行緒結束，如果結束則跳轉執行下一

countDownLatch.await()與thread.join()區別

在編寫多執行緒的工作中，有個常見的問題：主執行緒（main) 啟動好幾個子執行緒（task）來完成併發任務，主執行緒要等待所有的子執行緒完成之後才繼續執行main的其它任務。 預設主執行緒退出時其它子執行緒不會停，如果想讓main退出時其它子執行緒終止，可以用subThread.set

Thread.join方法的解析（轉）

原文連結：https://www.cnblogs.com/huangzejun/p/7908898.html   1. join() 的示例和作用 1.1 示例 1 // 父執行緒 2 public class Parent extends Thread { 3

【轉載】關於C#中Thread.Join()的一點理解

今天是第一次在C#中接觸Thread，自己研究了一下其中Thread.Join()這個方法，下面談談自己的理解。 Thread.Join()在MSDN中的解釋很模糊：Blocks the calling thread until a thread terminates 有兩個主

c++併發程式設計之thread::join()和thread::detach()

thread::join(): 阻塞當前執行緒，直至 *this 所標識的執行緒完成其執行。*this 所標識的執行緒的完成同步於從 join() 的成功返回。 該方法簡單暴力，主執行緒等待子程序期間什麼都不能做。thread::join()會清理子執行緒相關的記憶體空間，

C# 執行緒 正確使用Thread.Join()停止方式

/// <summary>        /// 停下執行緒        /// </summary>   &nb

C# 線程 正確使用Thread.Join()停止方式

join() dst 否則 dstat read oid cep reading void /// <summary> /// 停下線程 /// </summary> private void MyStopT

head first Thread.join()

友情推薦： 執行緒池原理 深入Thread.sleep 多執行緒中斷機制 不使用Thread.join() 測試執行緒 先上程式碼： /** * Created by Zero on 2017/8/23. */ public class Te

Java Thread.join()詳解--父執行緒等待子執行緒結束後再結束

一、使用方式。 join是Thread類的一個方法，啟動執行緒後直接呼叫，例如： ? 1 Thread t = new AThread(); t.start(); t.join();

Java Thread.join()方法

join()方法：讓主執行緒等待它的子執行緒死亡。即在一個執行緒中啟動新的執行緒，如果子執行緒呼叫了join方法，主執行緒會等子執行緒死亡後才會繼續往下執行。例子：public class ThreadJoin extends Thread{ public void r

執行緒間通訊_等待/通知之Thread.join()

Thread.join原始碼:public final synchronized void join(long millis) throws InterruptedException {

昨天讀了一本《外星人就在月球背面》，有點顛覆我的科學觀...

該書的主要觀點是說月球是一個巨大的宇宙飛船，被高等文明挖掘成一箇中空並且改造過的宇宙飛船。書中講到古時候的說說的“天”其實就是月亮，女媧補天就是指補月亮 ，遠古時期月亮和地球是離得比較近的，後來由於月球反叛者導致月亮遠離了月球。十日出現時月球的其他同伴帶來修補月

java多執行緒—Thread.Join()和Thread.Sleep()

其實我想要   一種美夢睡不著   一種心臟的狂跳   瓦解界線不被撂倒 奔跑 依靠   我心中最想要   看你看過的浪潮   陪你放肆地年少   ——林俊杰【偉大的渺小】 ------------

Java中用Thread.join實現單任務分成多個任務最後合併結果集

執行任務的具體執行緒類： package com.utils; import java.util.ArrayList; import java.util.List; public class MyThread extends Thread { private Lis

多執行緒--Thread.join方法

在Thread類的Api中，Join的作用是讓當前執行緒等待目標執行緒結束之後才繼續執行。 分別是 public final synchronized void join(long millis, int nanos)； //使當前執行緒等待目標執行緒millis 毫秒 ，nanos納秒之後，當

C++併發實戰2：thread::join和thread::detach

    thread::join()是個簡單暴力的方法，主執行緒等待子程序期間什麼都不能做，一般情形是主執行緒建立thread object後做自己的工作而不是簡單停留在join上。thread::join()還會清理子執行緒相關的記憶體空間，此後thread object