2. 程式人生 > >【Java】多執行緒系列（三）之阻塞執行緒的多種方法

【Java】多執行緒系列（三）之阻塞執行緒的多種方法

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

前言：

在某些應用場景下，我們可能需要等待某個執行緒執行完畢，然後才能進行後續的操作。也就是說，主執行緒需要等待子執行緒都執行完畢才能執行後續的任務。
例如，當你在計算利用多執行緒執行幾個比較耗時的任務的時候，主執行緒需要利用這幾個執行緒計算的結果，才能進行後續的操作。那麼我們其實就需要等待所有執行緒執行完畢。

這裡，介紹幾個常用的方法

執行緒執行單次的場景下

1，利用Thread類的join（）方法

package concurrent;

import java.util.ArrayList;
import java.util.List;

public class JoinTest {
    public
 
 static void main(String[] args) {
        List<Thread> list=new ArrayList<>();
        for(int i=0;i<5;i++){
            Thread t=new Thread(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+" is running!"
 
);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            list.add(t);
            t.start();
        }
        for(int i=0
 
;i<5;i++){
            try {
                list.get(i).join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread()+" is running!");
    }

}

程式執行結果如下：

Thread-2 is running!
Thread-0 is running!
Thread-1 is running!
Thread-3 is running!
Thread-4 is running!
Thread[main,5,main] is running!

注：

對於上面的join（）進行執行緒阻塞的時候，需要注意一下另外一種情況： 上面的5個執行緒，每次執行緒start（）之後立即呼叫join（）
這樣會產生類似於單執行緒模式，即5個執行緒序列化形式組織，順序執行。

2，利用ExecutorService的invokeAll（）方法

package concurrent;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceInvokeAllTest {
    public static void main(String[] args) {
        ExecutorService exec=Executors.newFixedThreadPool(5);
        List<Callable<String>> list=new ArrayList<>();
        for(int i=0;i<5;i++){
            callableTest cl=new callableTest();
            list.add(cl);
        }
        try {
            exec.invokeAll(list);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread()+" is running!");
        exec.shutdown();
    }
}
class callableTest implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread()+" is running!");
        Thread.sleep(1000);//模擬執行緒執行的耗時過程
        return null;
    }

}

程式執行結果：

Thread[pool-1-thread-1,5,main] is running!
Thread[pool-1-thread-3,5,main] is running!
Thread[pool-1-thread-2,5,main] is running!
Thread[pool-1-thread-5,5,main] is running!
Thread[pool-1-thread-4,5,main] is running!
Thread[main,5,main] is running!

invokeAll是一個阻塞方法，會等待任務列表中的所有任務都執行完成。等待所有的任務完成之後，就會返回一個Future的列表，裡面記錄了每個執行緒執行之後的結果。一旦ExecutorService.invokeAll()方法產生了異常，執行緒池中還沒有完成的任務會被取消執行。

3，利用Future的get（）方法

package concurrent;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureTest {
    public static void main(String[] args) {
        ExecutorService exc=Executors.newFixedThreadPool(5);
        Set<Future<Integer>> set = new HashSet<Future<Integer>>();
        for(int i=0;i<5;i++){
            callTest cl=new callTest();
            Future<Integer> f=exc.submit(cl);
            set.add(f);
        }
        int num=0;
        for(Future<Integer> f:set){
            try {
                num+=f.get();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread()+" is running!");
        System.out.println("The value num="+num);
        exc.shutdown();
    }
}
class callTest implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread()+" is running!");
        Thread.sleep(1000);
        return Integer.valueOf(1);
    }
}

輸出結果如下：

Thread[pool-1-thread-1,5,main] is running!
Thread[pool-1-thread-3,5,main] is running!
Thread[pool-1-thread-2,5,main] is running!
Thread[pool-1-thread-4,5,main] is running!
Thread[pool-1-thread-5,5,main] is running!
Thread[main,5,main] is running!
The value num=5

Runnable是執行工作的獨立任務，不返回任何結果。如果希望在任務完成之後，能夠返回一個值，那麼可以實現Callable介面而不是Runnable介面。在Java SE5中引入的Callable是一種具有型別引數的泛型，它的型別引數表示的是從方法call（）中返回的值，並且必須使用ExecutorService.submit（）方法呼叫它。
submit（）方法會產生Future物件，它用Callable返回的結果的特定型別進行了引數化。你可以使用isDone（）方法來檢視Future是否已經完成。當任務完成時，就會返回結果，可以呼叫get（）方法來獲取返回的結果。當然，也可以不用isDone（）方法進行檢查就可以直接呼叫get（），在這種情況下，get（）方法就會被阻塞，直至返回結果就緒。

4，利用ExecutorService的awaitTermination（）方法

package concurrent;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ESawaitTerminationTest {
    public static void main(String[] args) {
        ExecutorService exc=Executors.newFixedThreadPool(5);
        for(int i=0;i<5;i++){
            Thread thread=new Thread(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread()+" is running!");
                    try {
                        int temp=new Random().nextInt(5000);
                        System.out.println("sleep duration: "+temp+"ms");
                        sleep(temp);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            exc.execute(thread);
        }
        exc.shutdown();
        try {
            while(!exc.awaitTermination(1, TimeUnit.SECONDS)){
                System.out.println("Executors is not terminated!");
            }
            System.out.println("Executors is terminated!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

輸出結果如下：

Thread[pool-1-thread-2,5,main] is running!
Thread[pool-1-thread-1,5,main] is running!
Thread[pool-1-thread-3,5,main] is running!
sleep duration: 80ms
sleep duration: 468ms
sleep duration: 1200ms
Thread[pool-1-thread-5,5,main] is running!
sleep duration: 195ms
Thread[pool-1-thread-4,5,main] is running!
sleep duration: 2209ms
Executors is not terminated!
Executors is not terminated!
Executors is terminated!

上面的awaitTermination（）方法也可以使用isTerminated（）方法進行判斷，同時在while（）迴圈體內加一個Thread.sleep（）方法，即每隔一段時間檢查一遍執行緒池是否終止。這兩個方法是同樣的效果！

5，利用CountDownLatch

CountDownLatch類可以生成指定數目的鎖，每把鎖對應一個執行緒，每個執行緒執行完畢之後，就可以相應的減少一把鎖。當鎖的數目減為0之後，相當於所有的鎖都已經”歸還“，所有執行緒執行完畢。

package concurrent;

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) {
        CountDownLatch cl=new CountDownLatch(5);
        for(int i=0;i<5;i++){
            Thread t=new Thread(){
                public void run() {
                    System.out.println(Thread.currentThread()+" is running!");
                    int temp=new Random().nextInt(5000);
                    System.out.println("sleep duration: "+temp+"ms");
                    try {
                        sleep(temp);
                        cl.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                };
            };
            t.start();
        }
        try {
            cl.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread()+" is running!");
    }
}

輸出結果如下：

Thread[Thread-0,5,main] is running!
Thread[Thread-3,5,main] is running!
Thread[Thread-2,5,main] is running!
Thread[Thread-1,5,main] is running!
sleep duration: 1105ms
sleep duration: 1169ms
sleep duration: 4168ms
sleep duration: 642ms
Thread[Thread-4,5,main] is running!
sleep duration: 1949ms
Thread[main,5,main] is running!

迴圈業務場景下的使用

很多時候，一些執行緒為了實現定時更新的功能，就會每隔一段時間，迴圈執行某個任務。

例如：

web開發中，主執行緒M，子執行緒A、B。M需要等待子執行緒A、B至少各自完成一次任務執行才能進行後面的任務執行。之後子執行緒A、B就每隔一段時間迴圈執行任務去更新資料。

那麼這種場景下如何實現需求呢？

參見筆者之前的多執行緒系列中的一篇文章：

相關推薦

【Java】多執行緒系列（三）之阻塞執行緒的多種方法

前言： 在某些應用場景下，我們可能需要等待某個執行緒執行完畢，然後才能進行後續的操作。也就是說，主執行緒需要等待子執行緒都執行完畢才能執行後續的任務。 例如，當你在計算利用多執行緒執行幾個比較耗時的任務的時候，主執行緒需要利用這幾個執行緒計算的結果，才能進行後

【開源】OSharp框架學習系列（1）：總體設計及系列導航

正是 html 組織 內聚性 權限 是什麽 enc 3-0 分發 OSharp是什麽？ 　　OSharp是個快速開發框架，但不是一個大而全的包羅萬象的框架，嚴格的說，OSharp中什麽都沒有實現。與其他大而全的框架最大的不同點，就是OSharp只做抽象封裝，不做實現。依賴註

【8】C++進階系列（過載）

1、過載規則 c++幾乎可以過載全部的運算子，而且只能夠過載c++已有的運算子。 其中，不能過載的運算子："." 、 ".*" 、"::"、"?:" 過載之後運算子的優先順序和結合性都不會改變。 運算子過載是針對新型資料的實際需要，對原有運算子進行適當的改造。例如： 使複數的物件

【selenium3+JAVA】介面自動化測試教程（三）——瀏覽器的全屏、最大化和設定大小位置

1、瀏覽器全屏 使用程式碼如下： ChromeDriver chrome = new ChromeDriver(); chrome.manage().window().fullscreen(); 如上程式碼會把瀏覽器全屏，效果嘛就是除了網站的內容部分，其他全部

【Tomcat】Tomcat原始碼解讀系列（一）——server.xml檔案的配置

Tomcat是JEE開發人員最常用到的開發工具，在Java Web應用的除錯開發和實際部署中，我們都可以看到Tomcat的影子。大多數時候，我們可以將Tomcat當做一個黑盒來看待，只需要將編寫的Java Web工程進行部署即可，但是，在遇到一些比較複雜難解決的問題時

【轉載】.NET Remoting學習筆記（三）信道

star fig cati 服務端 pro net string spa 處理類型 目錄 .NET Remoting學習筆記（一）概念 .NET Remoting學習筆記（二）激活方式 .NET Remoting學習筆記（三）信道 參考：♂風車車.Net .NET Fra

C# 多線程系列（三）

job row 空閑 最好 方式 不同的 運行時 作業 tun 線程池 創建線程需要時間，如果有不同的小任務要完成，就可以事先創建許多線程，在應完成這些任務時發出請求。這個線程數最好在需要更多線程時增加，在需要釋放資源時減少。 不需要自己創建這樣的一個列表。該列表由T

【 C 】經典抽象資料型別（ADT）之記憶體分配

C中的一些抽象資料型別（ADT）如連結串列、堆疊、佇列和樹等，連結串列已經在前幾篇博文有所討論，見： 後面的博文會相繼討論堆疊、佇列和樹的一些基本的相關知識！ 下面記錄一個最基本的問題，記憶體分配問題： 所有的 ADT 都必須明確一個問題，如何獲取記憶體

【Mycat】資料庫效能提升利器（三）——Mycat實現Mysql主從複製和讀寫分離

一、前言       在前一篇文章中，小編向大家 介紹了使用Mycat水平切分資料庫。可以說，使用了水平分庫後，資料庫提升還是很高的。如果想更高的提高資料庫效能，就可以考慮對Mysql進行主從複製和讀寫分離了。       在這篇部落格中，小編就向大家介紹基於Mycat的M

併發集合（三）使用阻塞執行緒安全的列表

宣告：本文是《 Java 7 Concurrency Cookbook 》的第六章，作者： Javier Fernández González  譯者：許巧輝 使用阻塞執行緒安全的列表 列表（list）是最基本的集合。一個列表中的元素數量是不確定的，並且你可以新增、讀取和刪除任意位置上的元素。

【轉】Netty那點事（三）Channel中的Pipeline

【原文】https://github.com/code4craft/netty-learning/blob/master/posts/ch3-pipeline.md Channel是理解和使用Netty的核心。Channel的涉及內容較多，這裡我使用由淺入深的介紹方法。在這篇文章中，我們主要介紹Channe

Docker在Linux上執行NetCore系列（三）在Linux上使用Docker執行Asp.NetCore Docker在Linux/Windows上執行NetCore文章系列

原文: Docker在Linux上執行NetCore系列（三）在Linux上使用Docker執行Asp.NetCore 轉發請註明此文章作者與路徑，請尊重原著，違者必究。   系列文章：https://www.cnblogs.com/alunchen/p/10121379.html

Java的高併發程式設計系列（三）

鎖定某物件o，如果o的屬性發生改變，不影響鎖的使用，但是如果o變成另外一個物件，則鎖定的物件發生改變，應該避免將鎖定物件的引用變成另外一個物件。 public class Demo17 {

【Derivation】隨機過程及應用（三）

Provement of Gaussian Distribution： 設正態分佈概率密度函式是 f(x)=12π−−√σ∗e−(x−u)22σ2 於是： ∫+∞−∞e−(x−u)22σ

【C++】C++類的學習（三）——運算子過載與友元函式

前言       前面的兩篇博文中介紹了類的一些基本特性，今天講一講運算子過載和友元。運算子過載      運算子過載是C++中一種形式的多型，運算子過載將過載的概念運用到運算子上，賦予運算子更多地含義。也許乍然一聽，似乎我們對它並不熟悉，其實它一直為我們使用，例如 * 運算

程序與執行緒學習（三）之執行緒之使用場合

在對程序、執行緒的學習稍加了解後，不僅會自問在什麼情況下要使用多執行緒？畢竟，對知識的學習而不在於知識本身，而是怎麼使用所學的知識，有什麼侷限性。 但從耗時來講，我對多執行緒做了一些測試：程式如下： 只有一個主執行緒來估計買票時間； #include "stdafx.h"

多目標優化系列（三）MOEA/D

摘要 該文中文名是：基於分解的多目標進化演算法。該方法將一個多目標優化問題分解為一組但目標優化問題並對他們同時優化。通過利用每一個子問題相鄰的子問題來優化他本身。 引言（摘錄） 多目標優化問題可以用該式子表示： 其中Ω是決策空間，F：Ω→

【 C 】經典抽象資料型別（ADT）之堆疊（用靜態陣列實現堆疊）

堆疊簡介 堆疊（stack）最鮮明的特點就是後進先出（Last-In First-Out，LIFO）的資料進出方式。 基本的堆疊操作通常被稱為 push 和 pop。push就是將一個新值壓入到堆疊的頂部， pop就是把堆疊頂部的值移出堆疊並返回這個值。堆疊只提供對它的頂

【c#】RabbitMQ學習文檔（三）Publish/Subscribe（發布/訂閱）

信息 factory ges 客戶端 直接 運行 com mit 在屏幕上 原文:【c#】RabbitMQ學習文檔（三）Publish/Subscribe（發布/訂閱） （本教程是使用Net客戶端，也就是針對微軟技術平臺的） 在前一個教程中，我們創建了一個工作隊列。工

python selenium系列（三）常用操作類型及方法

term src 依次 and cto color 自動化 off value 一 前言開展WEB UI自動化的核心思路，無非就是找到元素，然後操作元素這兩個內容。在python selenium系列（二）元素定位方式一文中，已經介紹了如何找到元素這項技能，本文將介紹第二項