2. 程式人生 > >Java執行緒池原理及四種執行緒池的使用

Java執行緒池原理及四種執行緒池的使用

阿新 • • 發佈：2019-01-31


一、執行緒池簡介：
    多執行緒技術主要解決處理器單元內多個執行緒執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。   
    假設一個伺服器完成一項任務所需時間為：T1 建立執行緒時間，T2 線上程中執行任務的時間，T3 銷燬執行緒時間。

    如果：T1 + T3 遠大於 T2，則可以採用執行緒池，以提高伺服器效能。
                一個執行緒池包括以下四個基本組成部分：
                1、執行緒池管理器（ThreadPool）：用於建立並管理執行緒池，包括 建立執行緒池，銷燬執行緒池，新增新任務；
                2、工作執行緒（PoolWorker）：執行緒池中執行緒，在沒有任務時處於等待狀態，可以迴圈的執行任務；
                3、任務介面（Task）：每個任務必須實現的介面，以供工作執行緒排程任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；
                4、任務佇列（taskQueue）：用於存放沒有處理的任務。提供一種緩衝機制。
               
    執行緒池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高伺服器程式效能的。它把T1，T3分別安排在伺服器程式的啟動和結束的時間段或者一些空閒的時間段，這樣在伺服器程式處理客戶請求時，不會有T1，T3的開銷了。
    執行緒池不僅調整T1,T3產生的時間段，而且它還顯著減少了建立執行緒的數目，看一個例子：
    假設一個伺服器一天要處理50000個請求，並且每個請求需要一個單獨的執行緒完成。線上程池中，執行緒數一般是固定的，所以產生執行緒總數不會超過執行緒池中執行緒的數目，而如果伺服器不利用執行緒池來處理這些請求則執行緒總數為50000。一般執行緒池大小是遠小於50000。所以利用執行緒池的伺服器程式不會為了建立50000而在處理請求時浪費時間，從而提高效率。

    程式碼實現中並沒有實現任務介面，而是把Runnable物件加入到執行緒池管理器（ThreadPool），然後剩下的事情就由執行緒池管理器（ThreadPool）來完成了

二、java類庫中提供的執行緒池簡介：

     java提供的執行緒池更加強大，相信理解執行緒池的工作原理，看類庫中的執行緒池就不會感到陌生了。


三、Java通過Executors提供四種執行緒池，分別為：
newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。
newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。
newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行。
newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

(1) newCachedThreadPool
建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。示例程式碼如下：

Java程式碼 複製程式碼收藏程式碼
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  7.   for (int i = 0; i < 10; i++) {  
  8.    final int index = i;  
  9.    try {  
  10.     Thread.sleep(index * 1000);  
  11.    } catch (InterruptedException e) {  
  12.     e.printStackTrace();  
  13.    }  
  14.    cachedThreadPool.execute(new Runnable() {  
  15.     public void run() {  
  16.      System.out.println(index);  
  17.     }  
  18.    });  
  19.   }  
  20.  }  
  21. }  
<span style="font-size:14px;">package 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++) {
   final int index = i;
   try {
    Thread.sleep(index * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   cachedThreadPool.execute(new Runnable() {
    public void run() {
     System.out.println(index);
    }
   });
  }
 }
}</span>

執行緒池為無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的執行緒，而不用每次新建執行緒。
 
(2) newFixedThreadPool
建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。示例程式碼如下：

Java程式碼 複製程式碼收藏程式碼
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  7.   for (int i = 0; i < 10; i++) {  
  8.    final int index = i;  
  9.    fixedThreadPool.execute(new Runnable() {  
  10.     public void run() {  
  11.      try {  
  12.       System.out.println(index);  
  13.       Thread.sleep(2000);  
  14.      } catch (InterruptedException e) {  
  15.       e.printStackTrace();  
  16.      }  
  17.     }  
  18.    });  
  19.   }  
  20.  }  
  21. }  
<span style="font-size:14px;">package 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++) {
   final int index = i;
   fixedThreadPool.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}</span>

 
因為執行緒池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒列印3個數字。
定長執行緒池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool
建立一個定長執行緒池，支援定時及週期性任務執行。延遲執行示例程式碼如下：

Java程式碼 複製程式碼收藏程式碼
  1. package test;  
  2. import java.util.concurrent.Executors;  
  3. import java.util.concurrent.ScheduledExecutorService;  
  4. import java.util.concurrent.TimeUnit;  
  5. public class ThreadPoolExecutorTest {  
  6.  public static void main(String[] args) {  
  7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  8.   scheduledThreadPool.schedule(new Runnable() {  
  9.    public void run() {  
  10.     System.out.println("delay 3 seconds");  
  11.    }  
  12.   }, 3, TimeUnit.SECONDS);  
  13.  }  
  14. }  
<span style="font-size:14px;">package 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);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}</span>

 
表示延遲3秒執行。

定期執行示例程式碼如下：

Java程式碼 複製程式碼收藏程式碼
  1. package test;  
  2. import java.util.concurrent.Executors;  
  3. import java.util.concurrent.ScheduledExecutorService;  
  4. import java.util.concurrent.TimeUnit;  
  5. public class ThreadPoolExecutorTest {  
  6.  public static void main(String[] args) {  
  7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  8.   scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
  9.    public void run() {  
  10.     System.out.println("delay 1 seconds, and excute every 3 seconds");  
  11.    }  
  12.   }, 1, 3, TimeUnit.SECONDS);  
  13.  }  
  14. }  
<span style="font-size:14px;">package 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);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}</span>

 
表示延遲1秒後每3秒執行一次。

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

Java程式碼 複製程式碼收藏程式碼
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
  7.   for (int i = 0; i < 10; i++) {  
  8.    final int index = i;  
  9.    singleThreadExecutor.execute(new Runnable() {  
  10.     public void run() {  
  11.      try {  
  12.       System.out.println(index);  
  13.       Thread.sleep(2000);  
  14.      } catch (InterruptedException e) {  
  15.       e.printStackTrace();  
  16.      }  
  17.     }  
  18.    });  
  19.   }  
  20.  }  
  21. }  
<span style="font-size:14px;">package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 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(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}</span>

 
結果依次輸出，相當於順序執行各個任務。

你可以使用JDK自帶的監控工具來監控我們建立的執行緒數量，執行一個不終止的執行緒，建立指定量的執行緒，來觀察：
工具目錄：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
執行程式做稍微修改：

Java程式碼 複製程式碼收藏程式碼
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();  
  7.   for (int i = 0; i < 100; i++) {  
  8.    final int index = i;  
  9.    singleThreadExecutor.execute(new Runnable() {  
  10.     public void run() {  
  11.      try {  
  12.       while(true) {  
  13.        System.out.println(index);  
  14.        Thread.sleep(10 * 1000);  
  15.       }  
  16.      } catch (InterruptedException e) {  
  17.       e.printStackTrace();  
  18.      }  
  19.     }  
  20.    });  
  21.    try {  
  22.     Thread.sleep(500);  
  23.    } catch (InterruptedException e) {  
  24.     e.printStackTrace();  
  25.    }  
  26.   }  
  27.  }  
  28. }  
<span style="font-size:14px;">package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();
  for (int i = 0; i < 100; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      while(true) {
       System.out.println(index);
       Thread.sleep(10 * 1000);
      }
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
   try {
    Thread.sleep(500);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}</span>

 
效果如下：

 

選擇我們執行的程式：

監控執行狀態

 

相關推薦

Java執行緒池原理及四種執行緒池的使用

 一、執行緒池簡介：     多執行緒技術主要解決處理器單元內多個執行緒執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。        假設一個伺服器完成一項任務所需

java 執行緒池詳解及四種執行緒池用法介紹

java 執行緒池詳解      Executor框架是一種將執行緒的建立和執行分離的機制。它基於Executor和ExecutorService介面，及這兩個介面的實現類ThreadPoolExecutor展開，Executor有一個內部執行緒池，並提供了將任務傳遞到池中

介紹new Thread的弊端及Java四種執行緒池的使用

介紹new Thread的弊端及Java四種執行緒池的使用，對Android同樣適用。本文是基礎篇，後面會分享下執行緒池一些高階功能。 1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？ Java

new Thread的弊端及Java四種執行緒池的使用

介紹new Thread的弊端及Java四種執行緒池的使用，對Android同樣適用。本文是基礎篇，後面會分享下執行緒池一些高階功能。 1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？ Java

Java ExecutorService四種執行緒池及ThreadPoolExecutor機制

一、Java 執行緒池 Java通過Executors提供四種執行緒池，分別為： 1、newCachedThreadPool：建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。（執行緒最大併發數不可控制） 2、newF

理解new Thread的弊端及Java四種執行緒池的使用

1.new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？ new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated

Java ExecutorService四種執行緒池及自定義ThreadPoolExecutor機制

一、Java 執行緒池 Java通過Executors提供四種執行緒池，分別為：1、newCachedThreadPool：建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。（執行緒最大併發數不可控制）；執行緒池為無限大，當執行第二個任務時若第一個任務已經

Java併發程式設計中四種執行緒池及自定義執行緒使用教程

引言 通過前面的文章，我們學習了Executor框架中的核心類ThreadPoolExecutor ，對於執行緒池的核心排程機制有了一定的瞭解，並且成功使用ThreadPoolExecutor 建立了執行緒池。 而在Java中，除了ThreadPoolExecutor ，Executor框

Java四種執行緒池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingle

轉自：https://www.cnblogs.com/baizhanshi/p/5469948.html 1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？ Java   1 2 3 4 5 6 7

Java 四種執行緒池 - 使用

轉：https://www.cnblogs.com/zhujiabin/p/5404771.html 介紹new Thread的弊端及Java四種執行緒池的使用，對Android同樣適用。本文是基礎篇，後面會分享下執行緒池一些高階功能。 1、new Thread的弊端 執行一個非同步任務你還

java:多執行緒(實現Runnable的原理)及二種方式的區別

* 1,看Thread類的建構函式,傳遞了Runnable介面的引用  * 2,通過init()方法找到傳遞的target給成員變數的target賦值 * 3,檢視run方法,發現run方法中有判斷,如果target不為null就會呼叫Runnable介面子類物件的run方法 *

#一篇文章讓你瞭解四種執行緒池，學習Java不在困惑

在Java開發中，有時遇到多執行緒的開發時，直接使用Thread操作，對程式的效能和維護上都是一個問題，使用Java提供的執行緒池來操作可以很好的解決問題，於是找了下API看到Java提供四種執行緒池使用，Java通過Executors提供四種執行緒池，分別為： 1、newCachedThrea

Java執行緒池原理及使用

java中的執行緒池是運用場景最多的併發框架。在開發過程中，合理的使用執行緒池能夠帶來下面的一些好處： 1、降低資源的消耗。 2、提高響應速度。 3、提高執行緒的可管理型。 1.1、執行緒池ThreadPoolExecutor工作原理 講解之前，我們先看一張原理

淺析Java中的四種執行緒池

1.使用執行緒池的好處 　　 2.JUC中幾種常用的執行緒池 java.util.concurrent包下的Executors工廠類，提供了一系列的執行緒池的建立方法，其構造方法如下： public ThreadPoolExecutor(int corePoolSize,　　　

Java四種執行緒池使用

Java 四種執行緒池的使用 https://juejin.im/post/59df0c1af265da432f301c8d 1，執行緒池的作用 執行緒池作用就是限制系統中執行執行緒的數量。 根據系統的環境情況，可以自動或手動設定執行緒數量，達到執行的最佳效果。 少

Java 四種執行緒池

介紹new Thread的弊端及Java四種執行緒池的使用，對Android同樣適用。本文是基礎篇，後面會分享下執行緒池一些高階功能。 1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？ new Thread(new Runna

Java ExecutorService四種執行緒池的例子與說明

1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎 new Thread(new Runnable() { @Override public void run() { // TODO Auto-gen

Java併發程式設計之深入執行緒池原理及實現

Java執行緒池在實際的應用開發中十分廣泛。雖然Java1.5之後在JUC包中提供了內建執行緒池可以拿來就用，但是這之前仍有許多老的應用和系統是需要程式設計師自己開發的。因此，基於執行緒池的需求背景、技術要求瞭解執行緒池原理和實現，一方面可以更為深刻理解Java多執行緒開發，有助於解決業務系統中因為執行緒問題

java中常見的四種執行緒池的區別

在使用執行緒時，可以這樣建立一個執行緒池： ExecutorService executorService= Executors.newCachedThreadPool(); executorService.execute(()-> System.out.println("run ..

new Thread的弊端 以及JAVA的四種執行緒池

1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？new Thread(new Runnable() { @Override public void run() { // TODO Auto-gene