2. 程式人生 > >Java多線程-線程池ThreadPoolExecutor構造方法和規則

Java多線程-線程池ThreadPoolExecutor構造方法和規則

阿新 • • 發佈：2018-08-02
解決 $1 核心 keepaliv 狀態 被拒絕 live link 限時

為什麽用線程池

博客地址 http://blog.csdn.net/qq_25806863

原文地址 http://blog.csdn.net/qq_25806863/article/details/71126867

有時候，系統需要處理非常多的執行時間很短的請求，如果每一個請求都開啟一個新線程的話，系統就要不斷的進行線程的創建和銷毀，有時花在創建和銷毀線程上的時間會比線程真正執行的時間還長。而且當線程數量太多時，系統不一定能受得了。

使用線程池主要為了解決一下幾個問題：

  • 通過重用線程池中的線程，來減少每個線程創建和銷毀的性能開銷。
  • 對線程進行一些維護和管理，比如定時開始，周期執行，並發數控制等等。

Executor

Executor是一個接口，跟線程池有關的基本都要跟他打交道。下面是常用的ThreadPoolExecutor的關系。

技術分享圖片

Executor接口很簡單，只有一個execute方法。

ExecutorService是Executor的子接口，增加了一些常用的對線程的控制方法，之後使用線程池主要也是使用這些方法。

AbstractExecutorService是一個抽象類。ThreadPoolExecutor就是實現了這個類。

ThreadPoolExecutor

構造方法

ThreadPoolExecutor是線程池的真正實現，他通過構造方法的一系列參數，來構成不同配置的線程池。常用的構造方法有下面四個：

技術分享圖片

  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue)
    • 1
    • 2
    • 3
    • 4
    • 5
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        RejectedExecutionHandler handler)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory,
                        RejectedExecutionHandler handler)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

構造方法參數說明

  • corePoolSize

    核心線程數，默認情況下核心線程會一直存活，即使處於閑置狀態也不會受存keepAliveTime限制。除非將allowCoreThreadTimeOut設置為true。

  • maximumPoolSize

    線程池所能容納的最大線程數。超過這個數的線程將被阻塞。當任務隊列為沒有設置大小的LinkedBlockingDeque時，這個值無效。

  • keepAliveTime

    非核心線程的閑置超時時間，超過這個時間就會被回收。

  • unit

    指定keepAliveTime的單位，如TimeUnit.SECONDS。當將allowCoreThreadTimeOut設置為true時對corePoolSize生效。

  • workQueue

    線程池中的任務隊列.

    常用的有三種隊列，SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。

  • threadFactory

    線程工廠，提供創建新線程的功能。ThreadFactory是一個接口，只有一個方法

    public interface ThreadFactory {
  Thread newThread(Runnable r);
}
    • 1
    • 2
    • 3

    通過線程工廠可以對線程的一些屬性進行定制。

    默認的工廠：

    static class DefaultThreadFactory implements ThreadFactory {
  private static final AtomicInteger poolNumber = new AtomicInteger(1);
  private final ThreadGroup group;
  private final AtomicInteger threadNumber = new AtomicInteger(1);
  private final String namePrefix;

  DefaultThreadFactory() {
      SecurityManager var1 = System.getSecurityManager();
      this.group = var1 != null?var1.getThreadGroup():Thread.currentThread().getThreadGroup();
      this.namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
  }

  public Thread newThread(Runnable var1) {
      Thread var2 = new Thread(this.group, var1, this.namePrefix + this.threadNumber.getAndIncrement(), 0L);
      if(var2.isDaemon()) {
          var2.setDaemon(false);
      }

      if(var2.getPriority() != 5) {
          var2.setPriority(5);
      }

      return var2;
  }
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

  • RejectedExecutionHandler

    RejectedExecutionHandler也是一個接口，只有一個方法

    public interface RejectedExecutionHandler {
  void rejectedExecution(Runnable var1, ThreadPoolExecutor var2);
}
    • 1
    • 2
    • 3

    當線程池中的資源已經全部使用，添加新線程被拒絕時，會調用RejectedExecutionHandler的rejectedExecution方法。

線程池規則

線程池的線程執行規則跟任務隊列有很大的關系。

  • 下面都假設任務隊列沒有大小限制：

    1. 如果線程數量<=核心線程數量，那麽直接啟動一個核心線程來執行任務，不會放入隊列中。
    2. 如果線程數量>核心線程數，但<=最大線程數，並且任務隊列是LinkedBlockingDeque的時候，超過核心線程數量的任務會放在任務隊列中排隊。
    3. 如果線程數量>核心線程數，但<=最大線程數，並且任務隊列是SynchronousQueue的時候，線程池會創建新線程執行任務，這些任務也不會被放在任務隊列中。這些線程屬於非核心線程，在任務完成後，閑置時間達到了超時時間就會被清除。
    4. 如果線程數量>核心線程數，並且>最大線程數，當任務隊列是LinkedBlockingDeque，會將超過核心線程的任務放在任務隊列中排隊。也就是當任務隊列是LinkedBlockingDeque並且沒有大小限制時，線程池的最大線程數設置是無效的，他的線程數最多不會超過核心線程數。
    5. 如果線程數量>核心線程數，並且>最大線程數，當任務隊列是SynchronousQueue的時候，會因為線程池拒絕添加任務而拋出異常。

  • 任務隊列大小有限時

    1. 當LinkedBlockingDeque塞滿時，新增的任務會直接創建新線程來執行，當創建的線程數量超過最大線程數量時會拋異常。
    2. SynchronousQueue沒有數量限制。因為他根本不保持這些任務，而是直接交給線程池去執行。當任務數量超過最大線程數時會直接拋異常。

規則驗證

前提

所有的任務都是下面這樣的，睡眠兩秒後打印一行日誌：

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

所有驗證過程都是下面這樣，先執行三個，再執行三個，8秒後，各看一次信息

executor.execute(myRunnable);
executor.execute(myRunnable);
executor.execute(myRunnable);
System.out.println("---先開三個---");
System.out.println("核心線程數" + executor.getCorePoolSize());
System.out.println("線程池數" + executor.getPoolSize());
System.out.println("隊列任務數" + executor.getQueue().size());
executor.execute(myRunnable);
executor.execute(myRunnable);
executor.execute(myRunnable);
System.out.println("---再開三個---");
System.out.println("核心線程數" + executor.getCorePoolSize());
System.out.println("線程池數" + executor.getPoolSize());
System.out.println("隊列任務數" + executor.getQueue().size());
Thread.sleep(8000);
System.out.println("----8秒之後----");
System.out.println("核心線程數" + executor.getCorePoolSize());
System.out.println("線程池數" + executor.getPoolSize());
System.out.println("隊列任務數" + executor.getQueue().size());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

驗證1

  1. 核心線程數為6，最大線程數為10。超時時間為5秒

    ThreadPoolExecutor executor = new ThreadPoolExecutor(6, 10, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    • 1
    ---先開三個---
核心線程數6
線程池線程數3
隊列任務數0
---再開三個---
核心線程數6
線程池線程數6
隊列任務數0
pool-1-thread-1 run
pool-1-thread-6 run
pool-1-thread-5 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-2 run
----8秒之後----
核心線程數6
線程池線程數6
隊列任務數0
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

可以看到每個任務都是是直接啟動一個核心線程來執行任務，一共創建了6個線程，不會放入隊列中。8秒後線程池還是6個線程，核心線程默認情況下不會被回收，不收超時時間限制。

驗證2

  1. 核心線程數為3，最大線程數為6。超時時間為5秒,隊列是LinkedBlockingDeque

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
    • 1
    ---先開三個---
核心線程數3
線程池線程數3
隊列任務數0
---再開三個---
核心線程數3
線程池線程數3
隊列任務數3
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之後----
核心線程數3
線程池線程數3
隊列任務數0
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    當任務數超過核心線程數時，會將超出的任務放在隊列中，只會創建3個線程重復利用。

驗證3

  1. 核心線程數為3，最大線程數為6。超時時間為5秒,隊列是SynchronousQueue
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
  • 1
---先開三個---
核心線程數3
線程池線程數3
隊列任務數0
---再開三個---
核心線程數3
線程池線程數6
隊列任務數0
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-6 run
pool-1-thread-4 run
pool-1-thread-5 run
pool-1-thread-1 run
----8秒之後----
核心線程數3
線程池線程數3
隊列任務數0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

當隊列是SynchronousQueue時，超出核心線程的任務會創建新的線程來執行，看到一共有6個線程。但是這些線程是費核心線程，收超時時間限制，在任務完成後限制超過5秒就會被回收。所以最後看到線程池還是只有三個線程。

驗證4

  1. 核心線程數是3，最大線程數是4，隊列是LinkedBlockingDeque

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
    • 1
---先開三個---
核心線程數3
線程池線程數3
隊列任務數0
---再開三個---
核心線程數3
線程池線程數3
隊列任務數3
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之後----
核心線程數3
線程池線程數3
隊列任務數0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

LinkedBlockingDeque根本不受最大線程數影響。

但是當LinkedBlockingDeque有大小限制時就會受最大線程數影響了

4.1 比如下面，將隊列大小設置為2.

ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(2));
  • 1
---先開三個---
核心線程數3
線程池線程數3
隊列任務數0
---再開三個---
核心線程數3
線程池線程數4
隊列任務數2
pool-1-thread-2 run
pool-1-thread-1 run
pool-1-thread-4 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之後----
核心線程數3
線程池線程數3
隊列任務數0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

首先為三個任務開啟了三個核心線程1，2，3，然後第四個任務和第五個任務加入到隊列中，第六個任務因為隊列滿了，就直接創建一個新線程4，這是一共有四個線程，沒有超過最大線程數。8秒後，非核心線程收超時時間影響回收了，因此線程池只剩3個線程了。

4.2 將隊列大小設置為1

ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(1));
  • 1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.sunlinlin.threaddemo.Main$1@677327b6 rejected from java.util.concurrent.ThreadPoolExecutor@14ae5a5[Running, pool size = 4, active threads = 4, queued tasks = 1, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at com.sunlinlin.threaddemo.Main.main(Main.java:35)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
---先開三個---
核心線程數3
線程池線程數3
隊列任務數0
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-1 run
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

直接出錯在第6個execute方法上。因為核心線程是3個，當加入第四個任務的時候，就把第四個放在隊列中。加入第五個任務時，因為隊列滿了，就創建新線程執行，創建了線程4。當加入第六個線程時，也會嘗試創建線程，但是因為已經達到了線程池最大線程數，所以直接拋異常了。

驗證5

  1. 核心線程數是3 ，最大線程數是4，隊列是SynchronousQueue

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    • 1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.sunlinlin.threaddemo.Main$1@14ae5a5 rejected from java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 4, active threads = 4, queued tasks = 0, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at com.sunlinlin.threaddemo.Main.main(Main.java:34)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
---先開三個---
核心線程數3
線程池線程數3
隊列任務數0
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-1 run
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

這次在添加第五個任務時就報錯了，因為SynchronousQueue各奔不保存任務，收到一個任務就去創建新線程。所以第五個就會拋異常了。

Java多線程-線程池ThreadPoolExecutor構造方法和規則

相關推薦

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則 Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則 2017年05月03日 17:15:37 閱讀數：40542 為什麼用執行緒池 部落格地址 http://blog.csdn.ne

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則

為什麼用執行緒池 有時候，系統需要處理非常多的執行時間很短的請求，如果每一個請求都開啟一個新執行緒的話，系統就要不斷的進行執行緒的建立和銷燬，有時花在建立和銷燬執行緒上的時間會比執行緒真正執行的時間還長。而且當執行緒數量太多時，系統不一定能受得了。 使用執

Java多線程-線程池ThreadPoolExecutor構造方法和規則

解決 $1 核心 keepaliv 狀態 被拒絕 live link 限時 為什麽用線程池 博客地址 http://blog.csdn.net/qq_25806863 原文地址 http://blog.csdn.net/qq_25806863/article/details

Java多執行緒 - 執行緒池 ThreadPoolExecutor類的使用

ThreadPoolExecutor類可以非常方便的建立執行緒池物件，而不需要程式設計師設計大量的new去例項化Thread相關的程式碼 最常用的構造方法 (不過threadFactory可以視情況設或不設) ThreadPoolExecutor(   &nb

Java多執行緒-執行緒池ThreadPoolExecutor的submit返回值Future

開發十年，就只剩下這套架構體系了！ >>>   

java:Eclipse使用快捷鍵，快速建立構造方法和get/set方法

`public class person { private String name; private int age; public person() {//alt+shift+s 在加c,建立父類空參建構函式 super(); } public person(String nam

一心多用多執行緒-執行緒池ThreadPoolExecutor-看這篇就夠了

首先先寫一下執行緒池的概念： 執行緒池：執行緒池是一種多執行緒處理形式，處理過程中將任務新增到佇列，然後在建立執行緒後自動啟動這些任務。執行緒池執行緒都是後臺執行緒。每個執行緒都使用預設的堆疊大小，以預設的優先順序執行，並處於多執行緒單元中。如果某個執行緒在託管程式碼中空閒（如正在等待某個

java-多執行緒-執行緒池

       執行緒池本質是一種空間換時間的思想        需要處理非常多請求時候，如果每一個請求都開啟一個新執行緒的話，系統就要不斷的進行執行緒的建立和銷燬，是一項十分消耗資源的操作，且當執行緒數量太多時，系統不一定能受得了。 通過複用執行緒池中的執行緒，來避免

Java多執行緒-----執行緒池的使用，原理以及舉例實現（三）（四）：使用樣例及如何配置執行緒池大小

三.使用示例 　　前面我們討論了關於執行緒池的實現原理，這一節我們來看一下它的具體使用： public class Test { public static void main(String[] args) { ThreadPoolExe

深入理解Java多執行緒--執行緒池（ThreadPool）

在java多執行緒開發中，我們需要使用執行緒的時候一般是建立一個Thread物件，然後呼叫start（）方法去執行執行緒操作。這樣做沒有什麼問題，但是如果我們有很多工需要多個執行緒來非同步執行的時候，在我們建立了很多執行緒的情況下，會造成很大的效能方面的問題。 1.大量的執行緒的建立和銷燬，

JAVA併發程式設計：執行緒池 ThreadPoolExecutor

生活 前期追深度，否則會華而不實，後期追廣度，否則會坐井觀天； 前言 在前面，我們已經對Thread有了比較深入的瞭解，並且已經學會了通過new Thread()來建立一個執行緒，並通過start方法來啟動一個執行緒，這種方法非常簡單，同樣也存在弊端： 1、每次通過new Thr

Java多執行緒-----執行緒池詳解

   1. 執行緒池的實現原理       提交一個任務到執行緒池中，執行緒池的處理流程如下： 判斷執行緒池裡的核心執行緒是否都在執行任務，如果不是（核心執行緒空閒或者還有核心執行緒沒有被建立）則建立一個新的工作執行緒來執行任務。如果核心執行緒都在執

Java多執行緒-執行緒池Executors

概覽 通過上一篇對ThreadPoolExecutor的構造方法分析可以感受到，通過ThreadPoolExecutor來建立執行緒池是比較複雜的，引數比較多，考慮因素也多。 因此java自己提供了一個工廠類Executors，裡面提供了一些方法，用

07 進程池的同步方法和異步方法

.get 運行 proc pro pytho python apply tar append import time from multiprocessing import Process,Pool def f1(n): time.sleep(0.5) #

Java多執行緒執行緒池（4）--執行緒池的五種狀態

執行緒池的5種狀態：Running、ShutDown、Stop、Tidying、Terminated。 執行緒池各個狀態切換框架圖： 1、RUNNING (1) 狀態說明：執行緒池處在RUNNING狀態時，能夠接收新任務，以及對已新增的任務進行處理。

跟我學Java多執行緒——執行緒池與阻塞佇列

前言     上一篇文章中我們將ThreadPoolExecutor進行了深入的學習和介紹，實際上我們在專案中應用的時候很少有直接應用ThreadPoolExecutor來建立執行緒池的，在jdk的api中有這麼一句話“但是，強烈建議程式設計師使用較為方便的 Execu

Java併發包中執行緒池ThreadPoolExecutor原理探究

一、執行緒池簡介 　　執行緒池的使用主要是解決兩個問題：①當執行大量非同步任務的時候執行緒池能夠提供更好的效能，在不使用執行緒池時候，每當需要執行非同步任務的時候直接new一個執行緒來執行的話，執行緒的建立和銷燬都是需要開銷的。而執行緒池中的執行緒是可複用的，不需要每次執行非同步任務的時候重新建立和銷燬執行

Java入門系列之執行緒池ThreadPoolExecutor原理分析思考（十五）

前言 關於執行緒池原理分析請參看《http://objcoding.com/2019/04/25/threadpool-running/》，建議對原理不太瞭解的童鞋先看下此文然後再來看本文，這裡通過對原理的學習我談談對執行緒池的理解，若有錯誤之處，還望批評指正。 執行緒池思考 執行緒池我們可認為是準備好執行應

Java併發程式設計：執行緒池ThreadPoolExecutor

　　多執行緒的程式的確能發揮多核處理器的效能。雖然與程序相比，執行緒輕量化了很多，但是其建立和關閉同樣需要花費時間。而且執行緒多了以後，也會搶佔記憶體資源。如果不對執行緒加以管理的話，是一個非常大的隱患。而執行緒池的目的就是管理執行緒。當你需要一個執行緒時，你就可以拿一個空閒執行緒去執行任務，當任務執行完後，

Java多執行緒-執行緒池的使用

[toc] # 執行緒池的優點 - 執行緒頻繁的`建立=>銷燬=>建立`對系統對開銷很大，使用執行緒池可以避免重複的開銷 - 方便複用，提高相應速度 - 執行緒的創建於執行完全分開，方便維護，降低耦合 # 執行緒池的實現原理 ## 池化技術 一說到執行緒池自然就會想到**池化技術**。 其實所謂池