java線程池處理_什麼是java線程池

❶ java線程池怎麼實現的

線程池簡介：

多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。

假設一個伺服器完成一項任務所需時間為：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）來完成了

packagemine.util.thread;

importjava.util.LinkedList;
importjava.util.List;

/**
*線程池類，線程管理器：創建線程，執行任務，銷毀線程，獲取線程基本信息
*/
publicfinalclassThreadPool{
//線程池中默認線程的個數為5
privatestaticintworker_num=5;
//工作線程
privateWorkThread[]workThrads;
//未處理的任務
_task=0;
//任務隊列，作為一個緩沖,List線程不安全
privateList<Runnable>taskQueue=newLinkedList<Runnable>();
;

//創建具有默認線程個數的線程池
privateThreadPool(){
this(5);
}

//創建線程池,worker_num為線程池中工作線程的個數
privateThreadPool(intworker_num){
ThreadPool.worker_num=worker_num;
workThrads=newWorkThread[worker_num];
for(inti=0;i<worker_num;i++){
workThrads[i]=newWorkThread();
workThrads[i].start();//開啟線程池中的線程
}
}

//單態模式，獲得一個默認線程個數的線程池
(){
returngetThreadPool(ThreadPool.worker_num);
}

//單態模式，獲得一個指定線程個數的線程池,worker_num(>0)為線程池中工作線程的個數
//worker_num<=0創建默認的工作線程個數
(intworker_num1){
if(worker_num1<=0)
worker_num1=ThreadPool.worker_num;
if(threadPool==null)
threadPool=newThreadPool(worker_num1);
returnthreadPool;
}

//執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(Runnabletask){
synchronized(taskQueue){
taskQueue.add(task);
taskQueue.notify();
}
}

//批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(Runnable[]task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}

//批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(List<Runnable>task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}

//銷毀線程池,該方法保證在所有任務都完成的情況下才銷毀所有線程，否則等待任務完成才銷毀
publicvoiddestroy(){
while(!taskQueue.isEmpty()){//如果還有任務沒執行完成，就先睡會吧
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
//工作線程停止工作，且置為null
for(inti=0;i<worker_num;i++){
workThrads[i].stopWorker();
workThrads[i]=null;
}
threadPool=null;
taskQueue.clear();//清空任務隊列
}

//返回工作線程的個數
publicintgetWorkThreadNumber(){
returnworker_num;
}

//返回已完成任務的個數,這里的已完成是只出了任務隊列的任務個數，可能該任務並沒有實際執行完成
(){
returnfinished_task;
}

//返回任務隊列的長度，即還沒處理的任務個數
publicintgetWaitTasknumber(){
returntaskQueue.size();
}

//覆蓋toString方法，返回線程池信息：工作線程個數和已完成任務個數
@Override
publicStringtoString(){
return"WorkThreadnumber:"+worker_num+"finishedtasknumber:"
+finished_task+"waittasknumber:"+getWaitTasknumber();
}

/**
*內部類，工作線程
*/
{
//該工作線程是否有效，用於結束該工作線程
privatebooleanisRunning=true;

/*
*關鍵所在啊，如果任務隊列不空，則取出任務執行，若任務隊列空，則等待
*/
@Override
publicvoidrun(){
Runnabler=null;
while(isRunning){//注意，若線程無效則自然結束run方法，該線程就沒用了
synchronized(taskQueue){
while(isRunning&&taskQueue.isEmpty()){//隊列為空
try{
taskQueue.wait(20);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
if(!taskQueue.isEmpty())
r=taskQueue.remove(0);//取出任務
}
if(r!=null){
r.run();//執行任務
}
finished_task++;
r=null;
}
}

//停止工作，讓該線程自然執行完run方法，自然結束
publicvoidstopWorker(){
isRunning=false;
}
}
}

❷ java線程池（一）簡述線程池的幾種使用方式

首先說明下java線程是如何實現線程重用的
1. 線程執行完一個Runnable的run()方法後，不會被殺死
2. 當線程被重用時，這個線程會進入新Runnable對象的run()方法12

java線程池由Executors提供的幾種靜態方法創建線程池。下面通過代碼片段簡單介紹下線程池的幾種實現方式。後續會針對每個實現方式做詳細的說明
newFixedThreadPool
創建一個固定大小的線程池
添加的任務達到線程池的容量之後開始加入任務隊列開始線程重用總共開啟線程個數跟指定容量相同。
@Test
public void newFixedThreadPool() throws Exception {
ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService = Executors.newFixedThreadPool(1, new ThreadFactoryBuilder().build());
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();
}12345678

newSingleThreadExecutor
僅支持單線程順序處理任務
@Test
public void newSingleThreadExecutor() throws Exception {
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();

}123456789

newCachedThreadPool
這種情況跟第一種的方式類似，不同的是這種情況線程池容量上線是Integer.MAX_VALUE 並且線程池開啟緩存60s
@Test
public void newCachedThreadPool() throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService = Executors.newCachedThreadPool(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();

}123456789

newWorkStealingPool
支持給定的並行級別，並且可以使用多個隊列來減少爭用。
@Test
public void newWorkStealingPool() throws Exception {
ExecutorService executorService = Executors.newWorkStealingPool();
executorService = Executors.newWorkStealingPool(1);
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();

}123456789

newScheledThreadPool
看到的現象和第一種相同，也是在線程池滿之前是新建線程，然後開始進入任務隊列，進行線程重用
支持定時周期執行任務(還沒有看完)
@Test
public void newScheledThreadPool() throws Exception {
ExecutorService executorService = Executors.newScheledThreadPool(1);
executorService = Executors.newScheledThreadPool(1, new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();

}

❸ 什麼是java線程池

多線程是為了能夠讓計算機資源合理的分配，對於處理不同的任務創建不同的線程進行處理，但是計算機創建一個線程或者銷毀一個線程所花費的也是比較昂貴的，有時候需要同時處理的事情比較多，就需要我們頻繁的進行線程的創建和銷毀，這樣花費的時間也是比較多的。為了解決這一問題，我們就可以引用線程池的概念。
所謂線程池就是將線程集中管理起來，當需要線程的時候，可以從線程池中獲取空閑的線程，這樣可以減少線程的頻繁創建與銷毀，節省很大的時間和減少很多不必要的操作。
在java中提供了ThreadPoolExecutor類來進行線程的管理，這個類繼承於AbstractExecutorService，而AbstractExecutorService實現了ExecutorService介面，我們可以使用ThreadPoolExecutor來進行線程池的創建。
在ThreadPoolExecutor的構造方法中，有多個參數，可以配置不同的參數來進行優化。這個類的源碼構造方法為：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)其中每個參數代表的意義分別為
corePoolSize : 線程池中的核心線程數量，當線程池中當前的線程數小於這個配置的時候，如果有一個新的任務到來，即使線程池中還存在空閑狀態的線程，程序也會繼續創建一個新的線程放進線程池當中
maximumPoolSize: 線程池中的線程最大數量
keepAliveTime：當線程池中的線程數量大於配置的核心線程數量(corePoolSize)的時候，如果當前有空閑的線程，則當這個空閑線程可以存在的時間，如果在keepAliveTime這個時間點內沒有新的任務使用這個線程，那麼這個線程將會結束,核心線程不會結束，但是如果配置了allowCoreThreadTimeOut = true，則當空閑時間超過keepAliveTime之後，線程也會被結束調，默認allowCoreThreadTimeOut = false，即表示默認情況下，核心線程會一直存在於線程池當中。
unit : 空閑線程保持連接時間(keepAliveTime)的時間單位
workQueue：阻塞的任務隊列，用來保存等待需要執行的任務。
threadFactory ：線程工廠，可以根據自己的需求去創建線程的對象，設置線程的名稱，優先順序等屬性信息。
handler：當線程池中存在的線程數超過設置的最大值之後，新的任務就會被拒絕，可以自己定義一個拒絕的策略，當新任務被拒絕之後，就會使用hander方法進行處理。
在java中也提供了Executors工具類，在這個工具類中提供了多個創建線程池的靜態方法，其中包含newCachedThreadPool、newFixedThreadPool、newScheledThreadPool、newSingleThreadExecutor等。但是他們每個方法都是創建了ThreadPoolExecutor對象，不同的是，每個對象的初始參數值不一樣;

❹ 【Java基礎】線程池的原理是什麼

什麼是線程池？

總歸為：池化技術 ---》資料庫連接池緩存架構緩存池線程池內存池，連接池，這種思想演變成緩存架構技術---> JDK設計思想有千絲萬縷的聯系

首先我們從最核心的ThreadPoolExecutor類中的方法講起，然後再講述它的實現原理，接著給出了它的使用示例，最後討論了一下如何合理配置線程池的大小。

Java 中的 ThreadPoolExecutor 類

java.uitl.concurrent.ThreadPoolExecutor 類是線程池中最核心的一個類，因此如果要透徹地了解Java 中的線程池，必須先了解這個類。下面我們來看一下 ThreadPoolExecutor 類的具體實現源碼。

在 ThreadPoolExecutor 類中提供了四個構造方法：

❺ java常用的幾種線程池實例講解

下面給你介紹4種線程池：

1、newCachedThreadPool：

底層：返回ThreadPoolExecutor實例，corePoolSize為0；maximumPoolSize為Integer.MAX_VALUE；keepAliveTime為60L；unit為TimeUnit.SECONDS；workQueue為SynchronousQueue(同步隊列)
通俗：當有新任務到來，則插入到SynchronousQueue中，由於SynchronousQueue是同步隊列，因此會在池中尋找可用線程來執行，若有可以線程則執行，若沒有可用線程則創建一個線程來執行該任務；若池中線程空閑時間超過指定大小，則該線程會被銷毀。
適用：執行很多短期非同步的小程序或者負載較輕的伺服器

2、newFixedThreadPool：

底層：返回ThreadPoolExecutor實例，接收參數為所設定線程數量nThread，corePoolSize為nThread，maximumPoolSize為nThread；keepAliveTime為0L(不限時)；unit為：TimeUnit.MILLISECONDS；WorkQueue為：new LinkedBlockingQueue<Runnable>()無解阻塞隊列
通俗：創建可容納固定數量線程的池子，每隔線程的存活時間是無限的，當池子滿了就不在添加線程了；如果池中的所有線程均在繁忙狀態，對於新任務會進入阻塞隊列中(無界的阻塞隊列)
適用：執行長期的任務，性能好很多

3、newSingleThreadExecutor

底層：包裝的ThreadPoolExecutor實例，corePoolSize為1；maximumPoolSize為1；keepAliveTime為0L；unit為：TimeUnit.MILLISECONDS；workQueue為：new LinkedBlockingQueue<Runnable>()無解阻塞隊列
通俗：創建只有一個線程的線程池，且線程的存活時間是無限的；當該線程正繁忙時，對於新任務會進入阻塞隊列中(無界的阻塞隊列)
適用：一個任務一個任務執行的場景

4、NewScheledThreadPool:

底層：創建ScheledThreadPoolExecutor實例，corePoolSize為傳遞來的參數，maximumPoolSize為Integer.MAX_VALUE；keepAliveTime為0；unit為：TimeUnit.NANOSECONDS；workQueue為：new DelayedWorkQueue()一個按超時時間升序排序的隊列
通俗：創建一個固定大小的線程池，線程池內線程存活時間無限制，線程池可以支持定時及周期性任務執行，如果所有線程均處於繁忙狀態，對於新任務會進入DelayedWorkQueue隊列中，這是一種按照超時時間排序的隊列結構
適用：周期性執行任務的場景

最後給你說一下線程池任務執行流程：

當線程池小於corePoolSize時，新提交任務將創建一個新線程執行任務，即使此時線程池中存在空閑線程。
當線程池達到corePoolSize時，新提交任務將被放入workQueue中，等待線程池中任務調度執行
當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會創建新線程執行任務
當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理
當線程池中超過corePoolSize線程，空閑時間達到keepAliveTime時，關閉空閑線程
當設置allowCoreThreadTimeOut(true)時，線程池中corePoolSize線程空閑時間達到keepAliveTime也將關閉

❻ Java 線程池的問題

你的理解沒毛病。

核心線程數(corePoolSize）：核心線程會一直存活，即使沒有任務需要處理。當線程數小於核心線程數時，即使現有的線程空閑，線程池也蠢答會優先創建新線程來處理任務，而不是直接交給現有的線程處理。

最大線程數（maxPoolSize）：當線程數大於或等於核心線程，且任務隊列已滿時，線改叢程池會創建新的線程，直到線程數量達到maxPoolSize。如果線程數已等於maxPoolSize，且任務隊列已滿，則已超出線程池的處理能力，線程池會拒絕處理任務而拋出異常。

線程池按以下行為執行任務

當線程數小於核心線程數時，創建線程。
當線程數大於等於核心線程數，且任務隊列未滿時，將任務放入任務隊列。
當線程數大於等於核心線程數，且任務隊列已滿，1、若線程數小於最大線程數，創建線程；2、若線程數等於最大線程數，核檔櫻拋出異常，拒絕任務

❼ Java線程：新特徵-線程池

Sun在Java 中對Java線程的類庫做了大量的擴展其中線程池就是Java 的新特徵之一除了線程池之外還有很多多線程相關的內容為多線程的編程帶來了極大便利為了編寫高效穩定可靠的多線程程序線程部分的新增內容顯得尤為重要有關Java 線程新特徵的內容全部在ncurrent下面裡麵包含數目眾多的介面和類熟悉這部羨盯帶分API特徵是一項艱難的學習過程目前有關這方面的資料和書籍都少之又少大所屬介紹線程方面書籍還停留在java 之前的知識層面上當然新特徵對做多線程程序沒有必須的關系在java 之前通用可以寫出很優秀的多線程程序只是代價不一樣而已線程池的基本思想還是一種對象池的思想開辟一塊內存空間裡面存放了眾多（未死亡）的線程池中線程執行調度由池管理器來處理當有線程任務時從池中取一個執行完成後線程對象歸池這樣可以避免反復創建線程對象所帶來的性能開銷節省了系統的資源在Java 之前要實現一個線程池是相當有難度的現在Java 為我們做好了一切我們只需要按照提供的API來使用即可享受線程池帶來的極大便利則螞 Java 的線程池分好多種固定尺寸的線程池可變尺寸連接池在使用線程池之前必須知道如何去創建一個線程池在Java 中需要了解的是ncurrent Executors類的API 這個類提供大量創建連接池的靜態方法是必須掌握的 一固定大小的線程池 import ncurrent Executors; import ncurrent ExecutorService; /** * Java線程線程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //創建一個可重用固定線程數的線程池 ExecutorService pool = Executors newFixedThreadPool( ); //創建實現了Runnable介面對象 Thread對象當然也實現了Runnable介面 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); 兄蘆Thread t = new MyThread(); Thread t = new MyThread(); //將線程放入池中進行執行 pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); //關閉線程池 pool shutdown(); } } class MyThread extends Thread{ @Override public void run() { System out println(Thread currentThread() getName()+ 正在執行 ); } } pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 二單任務線程池 在上例的基礎上改一行創建pool對象的代碼為 //創建一個使用單個 worker 線程的 Executor 以無界隊列方式來運行該線程 ExecutorService pool = Executors newSingleThreadExecutor(); 輸出結果為 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 對於以上兩種連接池大小都是固定的當要加入的池的線程（或者任務）超過池最大尺寸時候則入此線程池需要排隊等待一旦池中有線程完畢則排隊等待的某個線程會入池執行

三可變尺寸的線程池 與上面的類似只是改動下pool的創建方式 //創建一個可根據需要創建新線程的線程池但是在以前構造的線程可用時將重用它們 ExecutorService pool = Executors newCachedThreadPool(); pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 四延遲連接池 import ncurrent Executors; import ncurrent ScheledExecutorService; import ncurrent TimeUnit; /** * Java線程線程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //創建一個線程池它可安排在給定延遲後運行命令或者定期地執行 ScheledExecutorService pool = Executors newScheledThreadPool( ); //創建實現了Runnable介面對象 Thread對象當然也實現了Runnable介面 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); //將線程放入池中進行執行 pool execute(t ); pool execute(t ); pool execute(t ); //使用延遲執行風格的方法 pool schele(t TimeUnit MILLISECONDS); pool schele(t TimeUnit MILLISECONDS); //關閉線程池 pool shutdown(); } } class MyThread extends Thread { @Override public void run() { System out println(Thread currentThread() getName() + 正在執行 ); } } pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code

五單任務延遲連接池 在四代碼基礎上做改動 //創建一個單線程執行程序它可安排在給定延遲後運行命令或者定期地執行 ScheledExecutorService pool = Executors (); pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 六自定義線程池 import ncurrent ArrayBlockingQueue; import ncurrent BlockingQueue; import ncurrent ThreadPoolExecutor; import ncurrent TimeUnit; /** * Java線程線程池自定義線程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //創建等待隊列 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>( ); //創建一個單線程執行程序它可安排在給定延遲後運行命令或者定期地執行 ThreadPoolExecutor pool = new ThreadPoolExecutor( TimeUnit MILLISECONDS bqueue); //創建實現了Runnable介面對象 Thread對象當然也實現了Runnable介面 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); //將線程放入池中進行執行 pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); //關閉線程池 pool shutdown(); } } class MyThread extends Thread { @Override public void run() { System out println(Thread currentThread() getName() + 正在執行 ); try { Thread sleep( L); } catch (InterruptedException e) { e printStackTrace(); } } }

pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 創建自定義線程池的構造方法很多本例中參數的含義如下

ThreadPoolExecutor

用給定的初始參數和默認的線程工廠及處理程序創建新的 ThreadPoolExecutor 使用 Executors 工廠方法之一比使用此通用構造方法方便得多參數 corePoolSize 池中所保存的線程數包括空閑線程 maximumPoolSize 池中允許的最大線程數 keepAliveTime 當線程數大於核心時此為終止前多餘的空閑線程等待新任務的最長時間 unit keepAliveTime 參數的時間單位 workQueue 執行前用於保持任務的隊列此隊列僅保持由 execute 方法提交的 Runnable 任務拋出 IllegalArgumentException 如果 corePoolSize 或 keepAliveTime 小於零或者 maximumPoolSize 小於或等於零或者 corePoolSize 大於 maximumPoolSize NullPointerException 如果 workQueue 為 null 自定義連接池稍微麻煩些不過通過創建的ThreadPoolExecutor線程池對象可以獲取到當前線程池的尺寸正在執行任務的線程數工作隊列等等有關Java 線程池的內容到此就沒有了更多的內容還需要研讀API來獲取 lishixin/Article/program/Java/hx/201311/26769

導航:首頁 > 編程語言 > java線程池處理

java線程池處理

線程池簡介：

ThreadPoolExecutor

與java線程池處理相關的資料