2. 程式人生 > >coding++：java 執行緒池概述

coding++：java 執行緒池概述

阿新 • • 發佈：2020-04-15

前言：

1）：建立一個可快取執行緒池

2）：建立一個可重用固定個數的執行緒池，以共享的無界佇列方式來執行這些執行緒。

3）：建立一個定長執行緒池，支援定時及週期性任務執行

4）：建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

5）：緩衝佇列BlockingQueue 和 自定義執行緒池 ThreadPoolExecutor

 

執行緒池簡介:

1.、執行緒池的概念：

　　執行緒池就是首先建立一些執行緒，它們的集合稱為執行緒池。

　　使用執行緒池可以很好地提高效能，執行緒池在系統啟動時即建立大量空閒的執行緒，程式將一個任務傳給執行緒池，執行緒池就會啟動一條執行緒來執行這個任務，執行結束以後，該執行緒並不會死亡，而是再次返回執行緒池中成為空閒狀態，

　　等待執行下一個任務。

2.、執行緒池的工作機制：

　　線上程池的程式設計模式下，任務是提交給整個執行緒池，而不是直接提交給某個執行緒，執行緒池在拿到任務後，就在內部尋找是否有空閒的執行緒，如果有，則將任務交給某個空閒的執行緒。

　　一個執行緒同時只能執行一個任務，但可以同時向一個執行緒池提交多個任務。

3.、使用執行緒池的原因：

        多執行緒執行時間，系統不斷的啟動和關閉新執行緒，成本非常高，會過渡消耗系統資源，以及過渡切換執行緒的危險，從而可能導致系統資源的崩潰。這時，執行緒池就是最好的選擇了

四種常見的執行緒池詳解：

1、執行緒池的返回值ExecutorService簡介：

         ExecutorService是Java提供的用於管理執行緒池的類。該類的兩個作用：控制執行緒數量 和 重用執行緒

2、具體的4種常用的執行緒池實現如下：（返回值都是ExecutorService）

        Executors.newCacheThreadPool()：可快取執行緒池，先檢視池中有沒有以前建立的執行緒，如果有，就直接使用。

　　如果沒有，就建一個新的執行緒加入池中，快取型池子通常用於執行一些生存期很短的非同步型任務

示例程式碼（一）：建立一個可快取執行緒池

package com.study.test;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //建立一個可快取執行緒池
         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
         for (int i = 0; i < 10; i++) {
             try {
                 //sleep可明顯看到使用的是執行緒池裡面以前的執行緒，沒有建立新的執行緒
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             cachedThreadPool.execute(new Runnable() {
                 public void run() {
                     //列印正在執行的快取執行緒資訊
                     System.out.println(Thread.currentThread().getName()+"正在被執行");
                 }
             });
         }
     }
}

輸出結果：

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

pool-1-thread-1正在被執行

執行緒池為無限大，當執行當前任務時上一個任務已經完成，會複用執行上一個任務的執行緒，而不用每次新建執行緒

示例程式碼（二）：Executors.newFixedThreadPool(int n)：建立一個可重用固定個數的執行緒池，以共享的無界佇列方式來執行這些執行緒。

示例程式碼：

package com.study.test;

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

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //建立一個可重用固定個數的執行緒池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        //列印正在執行的快取執行緒資訊
                        System.out.println(Thread.currentThread().getName()+"正在被執行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

輸出結果：

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

pool-1-thread-1正在被執行

因為執行緒池大小為3，每個任務輸出列印結果後sleep 2秒，所以每兩秒列印3個結果。

定長執行緒池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()

示例程式碼（三）：Executors.newScheduledThreadPool(int n)：建立一個定長執行緒池，支援定時及週期性任務執行

延遲執行示例程式碼：

package com.study.test;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //建立一個定長執行緒池，支援定時及週期性任務執行——延遲執行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延遲1秒執行
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("延遲1秒執行");
            }
        }, 1, TimeUnit.SECONDS);
    }
}

輸出結果：延遲1秒執行

定期執行示例程式碼：

package com.study.test;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //建立一個定長執行緒池，支援定時及週期性任務執行——定期執行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延遲1秒後每3秒執行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("延遲1秒後每3秒執行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }
} 

輸出結果：

延遲1秒後每3秒執行一次

延遲1秒後每3秒執行一次

示例程式碼（四）：Executors.newSingleThreadExecutor()：建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

示例程式碼： 

package com.study.test;

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

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        //建立一個單執行緒化的執行緒池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        //結果依次輸出，相當於順序執行各個任務
                        System.out.println(Thread.currentThread().getName()+"正在被執行,列印的值是:"+index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

輸出結果：

pool-1-thread-1正在被執行,列印的值是:0

pool-1-thread-1正在被執行,列印的值是:1

pool-1-thread-1正在被執行,列印的值是:2

pool-1-thread-1正在被執行,列印的值是:3

pool-1-thread-1正在被執行,列印的值是:4

pool-1-thread-1正在被執行,列印的值是:5

pool-1-thread-1正在被執行,列印的值是:6

pool-1-thread-1正在被執行,列印的值是:7

pool-1-thread-1正在被執行,列印的值是:8

pool-1-thread-1正在被執行,列印的值是:9

緩衝佇列BlockingQueue 和 自定義執行緒池 ThreadPoolExecutor

1、緩衝佇列BlockingQueue簡介：

          BlockingQueue是雙緩衝佇列。BlockingQueue內部使用兩條佇列，允許兩個執行緒同時向佇列一個儲存，一個取出操作。在保證併發安全的同時，提高了佇列的存取效率。

2、常用的幾種BlockingQueue：

　　ArrayBlockingQueue（int i）:規定大小的BlockingQueue，其構造必須指定大小。其所含的物件是FIFO順序排序的。

　　LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其構造時指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE來決定。其所含的物件是FIFO順序排序的。

　　PriorityBlockingQueue（）或者（int i）:類似於LinkedBlockingQueue，但是其所含物件的排序不是FIFO，而是依據物件的自然順序或者建構函式的Comparator決定。

　　SynchronizedQueue（）:特殊的BlockingQueue，對其的操作必須是放和取交替完成。

3. 自定義執行緒池（ThreadPoolExecutor和BlockingQueue連用）：

     自定義執行緒池，可以用ThreadPoolExecutor類建立，它有多個構造方法來建立執行緒池。

    常見的建構函式：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

示例程式碼：

package com.study.test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class TempThread implements Runnable {

    @Override
    public void run() {
        // 列印正在執行的快取執行緒資訊
        System.out.println(Thread.currentThread().getName() + "正在被執行");
        try {
            // sleep一秒保證3個任務在分別在3個執行緒上執行
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        // 建立陣列型緩衝等待佇列
        BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
        // ThreadPoolExecutor:建立自定義執行緒池，池中儲存的執行緒數為3，允許最大的執行緒數為6
        ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);

        // 建立3個任務
        Runnable t1 = new TempThread();
        Runnable t2 = new TempThread();
        Runnable t3 = new TempThread();// 3個任務在分別在3個執行緒上執行
        tpe.execute(t1);
        tpe.execute(t2);
        tpe.execute(t3);// 關閉自定義執行緒池
        tpe.shutdown();
    }
}

輸出結果：

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

 

更多：ThreadPoolExecutor 詳解 點選跳轉

&n

相關推薦

coding++：java 執行緒池概述

前言： 1）：建立一個可快取執行緒池 2）：建立一個可重用固定個數的執行緒池，以共享的無界佇列方式來執行這些執行緒。 3）：建立一個定長執行緒池，支援定時及週期性任務執行 4）：建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

美團面試題：Java-執行緒池 ThreadPool 專題詳解

去美團面試，問到了什麼是執行緒池，如何使用，為什麼要用,以下做個總結。關於執行緒之前也寫過一篇文章《高階面試題總結—執行緒池還能這麼玩？》 1、什麼是執行緒池：  java.util.concurrent.Executors提供了一個 java.util.conc

Java併發程式設計：Java執行緒池核心ThreadPoolExecutor的使用和原理分析

引出執行緒池 執行緒是併發程式設計的基礎，前面的文章裡，我們的例項基本都是基於執行緒開發作為例項，並且都是使用的時候就建立一個執行緒。這種方式比較簡單，但是存在一個問題，那就是執行緒的數量問題。 假設有一個系統比較複雜，需要的執行緒數很多，如果都是採用這種方式來建立執行緒的話，那麼就會極大的消耗系統資源。

上海某小公司面試題：Java執行緒池來聊聊

《對線面試官》系列目前已經連載**11**篇啦！進度是**一週更新兩篇**，歡迎持續關注 - [【對線面試官】Java註解](https://mp.weixin.qq.com/s?__biz=MzU4NzA3MTc5Mg==&mid=2247483821&idx=1&sn=e9003

深入理解Java執行緒池(1)：ThreadPoolExecutor整體流程梳理，建立worker相關方法

執行緒池作為一個執行緒的容器，主要的作用就是防止頻繁建立執行緒，節省時間資源和cpu資源。雖然一定程度上佔用了記憶體，但實際情況下利遠遠大於弊。 構造方法 public ThreadPoolExecutor( int corePoolSize, //核

乾貨：教你如何監控 Java 執行緒池執行狀態

之前寫過一篇 Java 執行緒池的使用介紹文章《執行緒池全面解析》，全面介紹了什麼是執行緒池、執行緒池核心類、執行緒池工作流程、執行緒池分類、拒絕策略、及如何提交與關閉執行緒池等。 但在實際開發過程中，線上程池使用過程中可能會遇到各方面的故障，如執行緒池阻塞，

java執行緒池之ThreadPoolExecutor(三)：提交任務並得到任務執行結果

1.Callable<V>介面 ThreadPoolExecutor不僅可以執行Runnable的實現類，還可以執行Callable介面的實現類。Callable的介面和Runnable介面的區別是：Callable有一個call方法能夠得到任務執行結果，而Ru

跟著阿里p7一起學java高併發 - 第18天：玩轉java執行緒池，這一篇就夠了

java中的執行緒池，這一篇就夠了 java高併發系列第18篇文章。 本文主要內容 什麼是執行緒池 執行緒池實現原理 執行緒池中常見的各種佇列 自定義執行緒建立的工廠 常見的飽和策略 自定義飽和策略 執行緒池中兩種關閉方法有何不同 擴充套件執行緒池 合理地配置執行緒池 執行緒池中執行緒數量的配置 什麼是執

Java執行緒池一：執行緒基礎

最近精讀Netty原始碼,讀到NioEventLoop部分的時候，發現對Java執行緒&執行緒池有些概念還有困惑， 所以深入總結一下 ### 執行緒建立 Java執行緒建立主要有三種方式：繼承Thread類、實現Runable介面、實現Callable介面 只有通過呼叫``Thread.star

深入淺出Java執行緒池：使用篇

## 前言 很高興遇見你~ 藉助於很多強大的框架，現在我們已經很少直接去管理執行緒，框架的內部都會為我們自動維護一個執行緒池。例如我們使用最多的okHttp以及他的封裝框架Retrofit，執行緒封裝框架RxJava和kotlin協程等等。為了更好地使用這些框架，則必須瞭解他的實現原理，而瞭解他的原理，執

深入淺出Java執行緒池：原始碼篇

## 前言 在上一篇文章[深入淺出Java執行緒池：理論篇](https://juejin.cn/post/6923856791117758472)中，已經介紹了什麼是執行緒池以及基本的使用。（本來寫作的思路是使用篇，但經網友建議後，感覺改為理論篇會更加合適）。本文則深入執行緒池的原始碼，主要是介紹Thre

java執行緒池趣味事：這不是執行緒池

　　要想寫出高效能高併發的應用，自然有許多關鍵，如io，演算法，非同步，語言特性，作業系統特性，佇列，記憶體，cpu，分散式，網路，資料結構，高效能元件。 　　胡說一通先。 　　回到主題，執行緒池。如果說多執行緒是提高系統併發能力利器之一，那麼執行緒池就是讓這個利器更容易控制的一種工具。如果我們自己純粹使用多

java執行緒池詳細入門教程即原始碼解析

##1、執行緒池概念      執行緒池是執行緒的集合，通過執行緒池我們不需要自己建立執行緒，將任務提交給執行緒池即可。為什麼要使用執行緒池，首先，使用執行緒池可以重複利用已有的執行緒繼續執行任務，避免執行緒在建立和銷燬時造成的消耗。其次，由

Java執行緒池ThreadPoolExecutor詳解

  1、執行緒池的工作原理？   執行緒池剛建立時，裡面沒有一個執行緒。任務佇列是作為引數傳進來的。不過，就算佇列裡面有任務，執行緒池也不會馬上執行它們。 當呼叫 execute() 方法新增一個任務時，執行緒池會做如下判斷：

java 執行緒池 ExecutorService相關歸納

public class ExecutorServiceDemo {     public static void main(String[] args) {          // 單執行緒池  &

Java執行緒池Executor框架詳解

Java的執行緒既是工作單元，也是執行機制。從JDK 5開始，把工作單元與執行機制分離開來。工作單元包括Runnable和Callable，而執行機制由Executor框架提供。 Executor框架簡介在HotSpot VM的執行緒模型中，Java執行緒（java.lang.Thread）被一對一對映為本

java執行緒池（有返回值和無返回值）

無返回值： package ThreadPool2; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class test { public stat

揭祕Java執行緒池的真相

執行緒池是指在初始化一個多執行緒應用程式過程中建立一個執行緒集合，然後在需要執行新的任務時重用這些執行緒而不是新建一個執行緒。執行緒池中執行緒的數量通常完全取決於可用記憶體數量和應用程式的需求。然而，增加可用執行緒數量是可能的。執行緒池中的每個執行緒都有被分配一個任務，一旦任務已經完成了，執行緒

Java執行緒池的認識、常用執行緒池的分析

什麼是程式，什麼是程序，什麼是執行緒，他們有什麼區別？   程式是指令和資料的有序集合，其本身並沒有任何執行的含義，是一個靜態的概念。 程序是一個動態的過程，是一個活動的實體。簡單來說，一個應用程式得到執行就可以看作是一個程序。程序可以包含多個同時執行的執行緒。程序也是擁有系統

【小家Java】一次Java執行緒池誤用（newFixedThreadPool）引發的線上血案和總結

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9