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

1. package mine.util.thread;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4. /** 
5.  * 執行緒池類，執行緒管理器：建立執行緒，執行任務，銷燬執行緒，獲取執行緒基本資訊 
6.  */
7. publicfinalclass ThreadPool {  
8.     // 執行緒池中預設執行緒的個數為5
9.     privatestaticint worker_num = 5;  
10.     // 工作執行緒
11.     private WorkThread[] workThrads;  
12.     // 未處理的任務
13.     privatestaticvolatileint finished_task = 0;  
14.     // 任務佇列，作為一個緩衝,List執行緒不安全
15.     private List<Runnable> taskQueue = new LinkedList<Runnable>();  
16.     privatestatic ThreadPool threadPool;  
17.     // 建立具有預設執行緒個數的執行緒池
18.     private ThreadPool() {  
19.         this(5);  
20.     }  
21.     // 建立執行緒池,worker_num為執行緒池中工作執行緒的個數
22.     private ThreadPool(int worker_num) {  
23.         ThreadPool.worker_num = worker_num;  
24.         workThrads = new WorkThread[worker_num];  
25.         for (int i = 0; i < worker_num; i++) {  
26.             workThrads[i] = new WorkThread();  
27.             workThrads[i].start();// 開啟執行緒池中的執行緒
28.         }  
29.     }  
30.     // 單態模式，獲得一個預設執行緒個數的執行緒池
31.     publicstatic ThreadPool getThreadPool() {  
32.         return getThreadPool(ThreadPool.worker_num);  
33.     }  
34.     // 單態模式，獲得一個指定執行緒個數的執行緒池,worker_num(>0)為執行緒池中工作執行緒的個數
35.     // worker_num<=0建立預設的工作執行緒個數
36.     publicstatic ThreadPool getThreadPool(int worker_num1) {  
37.         if (worker_num1 <= 0)  
38.             worker_num1 = ThreadPool.worker_num;  
39.         if (threadPool == null)  
40.             threadPool = new ThreadPool(worker_num1);  
41.         return threadPool;  
42.     }  
43.     // 執行任務,其實只是把任務加入任務佇列，什麼時候執行有執行緒池管理器覺定
44.     publicvoid execute(Runnable task) {  
45.         synchronized (taskQueue) {  
46.             taskQueue.add(task);  
47.             taskQueue.notify();  
48.         }  
49.     }  
50.     // 批量執行任務,其實只是把任務加入任務佇列，什麼時候執行有執行緒池管理器覺定
51.     publicvoid execute(Runnable[] task) {  
52.         synchronized (taskQueue) {  
53.             for (Runnable t : task)  
54.                 taskQueue.add(t);  
55.             taskQueue.notify();  
56.         }  
57.     }  
58.     // 批量執行任務,其實只是把任務加入任務佇列，什麼時候執行有執行緒池管理器覺定
59.     publicvoid execute(List<Runnable> task) {  
60.         synchronized (taskQueue) {  
61.             for (Runnable t : task)  
62.                 taskQueue.add(t);  
63.             taskQueue.notify();  
64.         }  
65.     }  
66.     // 銷燬執行緒池,該方法保證在所有任務都完成的情況下才銷燬所有執行緒，否則等待任務完成才銷燬
67.     publicvoid destroy() {  
68.         while (!taskQueue.isEmpty()) {// 如果還有任務沒執行完成，就先睡會吧
69.             try {  
70.                 Thread.sleep(10);  
71.             } catch (InterruptedException e) {  
72.                 e.printStackTrace();  
73.             }  
74.         }  
75.         // 工作執行緒停止工作，且置為null
76.         for (int i = 0; i < worker_num; i++) {  
77.             workThrads[i].stopWorker();  
78.             workThrads[i] = null;  
79.         }  
80.         threadPool=null;  
81.         taskQueue.clear();// 清空任務佇列
82.     }  
83.     // 返回工作執行緒的個數
84.     publicint getWorkThreadNumber() {  
85.         return worker_num;  
86.     }  
87.     // 返回已完成任務的個數,這裡的已完成是隻出了任務佇列的任務個數，可能該任務並沒有實際執行完成
88.     publicint getFinishedTasknumber() {  
89.         return finished_task;  
90.     }  
91.     // 返回任務佇列的長度，即還沒處理的任務個數
92.     publicint getWaitTasknumber() {  
93.         return taskQueue.size();  
94.     }  
95.     // 覆蓋toString方法，返回執行緒池資訊：工作執行緒個數和已完成任務個數
96.     @Override
97.     public String toString() {  
98.         return"WorkThread number:" + worker_num + "  finished task number:"
99.                 + finished_task + "  wait task number:" + getWaitTasknumber();  
100.     }  
101.     /** 
102.      * 內部類，工作執行緒 
103.      */
104.     privateclass WorkThread extends
     相關推薦

     Java中執行緒有幾種狀態

     線上程的生命週期裡，執行緒總共有6種狀態，這是Java5之後在公共內部列舉類Thread.State裡面宣告的。他們分別是 NEW:新建，表示的是執行緒被創建出來但還未被投入使用。 RUNNABLE：就緒，這個執行緒已經在JVM裡被執行，有可能是正在執行也有可能是等待CPU分配資源進入了就緒

     程序和程式關係類比/ java中執行緒是哪種實現【清華大學】作業系統

     本文分三個小節 1 執行緒模型 2 執行緒的實現  3 java中執行緒是使用者執行緒，核心執行緒，輕量級程序？？？ 3.1 臨界區 互斥 3.2 訊號量 管程 前兩小節是來自作業系統。 第三小節：看到作業系統中執行緒實現的三種方式，忽然想起我以

     java多執行緒的幾種實現方法

               方法一：繼承Thread類，覆蓋方法run（）， public class MyThread extends Thread { int count= 1, number; public MyThread(int num) { number = num;

     java多執行緒的6種實現方式詳解、執行緒池、定時器

     多執行緒的形式上實現方式主要有兩種，一種是繼承Thread類，一種是實現Runnable介面。本質上實現方式都是來實現執行緒任務，然後啟動執行緒執行執行緒任務（這裡的執行緒任務實際上就是run方法）。這裡所說的6種，實際上都是在以上兩種的基礎上的一些變形。 繼承Thread

     java 多執行緒的一種實現方式

     private ThreadPoolExecutor threadPoolExecutor; /** * 獲取執行緒池 * @return */ private ThreadPoolExecutor getThreadPoolExecutor(){

     Java多執行緒之四種實現方式

     介紹 繼承Thread類，並重寫其run方法 實現Runnable介面 實現Callable介面通過FutureTask包裝器來建立Thread執行緒 執行緒池，使用ExecutorService、Callable、Future實現有返回結果的多執行緒。 其

     java多執行緒的三種實現方式的極簡範例

     java提供了三種多執行緒的實現方式，分別為:繼承Thread類、實現Runnable介面 和 實現Callable<>介面。 繼承Thread類 執行緒的執行體是run()方法，所以我們只需要過載父類的run()方法。建立類物件，呼叫start()

     JAVA多執行緒的四種實現方式

     1.繼承Thread  重寫run()方法，該run方法表示執行緒要完成的任務。建立執行緒物件，呼叫物件的start（）方法來啟動執行緒。 2.Runnable介面 重寫介面中run方法。建立Runable例項類的例項，並依此例項作為Thread的target來建立Th

     java多執行緒的6種實現方式詳解

     多執行緒的形式上實現方式主要有兩種，一種是繼承Thread類，一種是實現Runnable介面。本質上實現方式都是來實現執行緒任務，然後啟動執行緒執行執行緒任務（這裡的執行緒任務實際上就是run方法）。這裡所說的6種，實際上都是在以上兩種的基礎上的一些變形。 繼承

     Java中阻塞佇列的幾種實現方式

     1.wait()和notify()方式(摘自:https://segmentfault.com/a/1190000000373535) 阻塞佇列與普通佇列的區別在於，當佇列是空的時，從佇列中獲取元素的操作將會被阻塞，或者當佇列是滿時，往佇列裡新增元素的操作會被阻塞。試圖從

     java中執行緒的兩種建立方式與比較

       首先，回顧一下作業系統課程中程序相關部分：  程序的定義：程序就是程式在一個數據集合上的一次執行過程。他與程式的區別在於程式是靜態的程式碼，而程序是動態的執行過程。  程序的特性：1.結構性，程序由程式塊、資料塊、程序控制塊（PCB）組成；          2.動態性，

     Java多執行緒的三種實現方式

     今天簡單說一下Java三種多執行緒實現方式和區別，主要有實現Runnable、Callable和繼承Thread三種方式。 實現Runnable的方式 這種方式比較常用，當我們的執行緒類有繼承其他的類的情況下（Java不支援類多繼承），並且執行緒任務不需要返回值的情況下可以選用這種方式。 1 public

     java中執行緒池的幾種實現方式

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

     沉澱再出發：java中執行緒池解析

     沉澱再出發：java中執行緒池解析 一、前言    在多執行緒執行的環境之中，如果執行緒執行的時間短但是啟動的執行緒又非常多，執行緒運轉的時間基本上浪費在了建立和銷燬上面，因此有沒有一種方式能夠讓一個執行緒執行完自己的任務之後又被重複使用呢？執行緒池的出現就是為了解決這個問題。到了現在

     Java中執行緒池基本api及其作用

     1.執行緒池相關的類 2.重要類的api及其方法 Executors.newCachedThreadPool() 建立一個可快取的執行緒池 Executors.newSingleThreadExecutor();建立一個只有一個執行緒執行的 不可修改的執行緒池  

     java中執行緒池的生命週期

     執行緒池生命週期包括: RUNNING:接收新的任務並處理佇列中的任務 SHUTDOWN:不接收新的任務，但是處理佇列中的任務 STOP:不接收新的任務，不處理佇列中的任務，同時中斷處理中的任務 TIDYING:所有的任務處理完成，有效的執行緒數是0 TERMINATED:termin

     Java中執行緒池，你真的會用嗎

     轉載自   Java中執行緒池，你真的會用嗎 在《深入原始碼分析Java執行緒池的實現原理》這篇文章中，我們介紹過了Java中執行緒池的常見用法以及基本原理。 在文中有這樣一段描述： 可以通過Executors靜態工廠構建執行緒池，但一般不建議這樣使用。 關於這個

     java中執行緒池的生命週期與執行緒中斷

     執行緒池生命週期包括: RUNNING:接收新的任務並處理佇列中的任務 SHUTDOWN:不接收新的任務，但是處理佇列中的任務 STOP:不接收新的任務，不處理佇列中的任務，同時中斷處理中的任務 TIDYING:所有的任務處理完成，有效的執行緒數是0 TE

     Java 執行緒池 四種建立方式

     Java通過Executors提供四種執行緒池，分別為： newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。 newFixedThreadPool 建立一個定長執行緒池，可

     Java中執行緒池，你真的瞭解會用嗎

     在《 深入原始碼分析Java執行緒池的實現原理 》這篇文章中，我們介紹過了Java中執行緒池的常見用法以及基本原理。 在文中有這樣一段描述： 可以通過Executors靜態工廠構建執行緒池，但一般不建議這樣使用。 關於這個問題，在那篇文章中並沒有深入的展開。作者之所以這