1.線程池的基本使用
1.1. 爲什麼需要線程池
假設一個服務器完成一項任務所需時間爲:T1 創建線程時間,T2 在線程中執行任務的時間,T3 銷燬線程時間。
如果:T1 + T3 遠大於 T2,則可以採用線程池,以提高服務器性能。
1.1.1. 假設一個服務器完成一項任務所需時間爲:T1 創建線程時間,T2 在線程中執行任務的時間,T3 銷燬線程時間, T1 + T3 遠大於 T2。
採用線程池減少了創建和銷燬線程的次數,每個工作線程都可以被重複利用,可執行多個任務。
1.1.2.可以根據系統的承受能力,調整線程池中工作線線程的數目,防止因爲消耗過多的內存,而把服務器累趴下(每個線程需要大約1MB內存,線程開的越多,消耗的內存也就越大,最後死機).
1.2.JDK爲我們提供了哪些支持
1.2.1. 內置線程池
1.3.線程池的使用
1.3.1. 線程池的種類
newFixedThreadPool
創建固定大小的線程池。每次提交一個任務就創建一個線程,直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變,如果某個線程因爲執行異常而結束,那麼線程池會補充一個新線程。
newSingleThreadExecutor
創建一個單線程的線程池。這個線程池只有一個線程在工作,也就是相當於單線程串行執行所有任務。如果這個唯一的線程因爲異常結束,那麼會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。
newCachedThreadPool
創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程,那麼就會回收部分空閒(60秒不執行任務)的線程,當任務數增加時,此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制,線程池大小完全依賴於操作系統(或者說JVM)能夠創建的最大線程大小。
newScheduledThreadPool
創建一個大小無限的線程池。此線程池支持定時以及週期性執行任務的需求。
1.3.2. 不同線程池的共同性
在下面線程池及其核心代碼分析一節中會有所體現。
1.4. 線程池使用的小例子
1.4.1. 簡單線程池
public class fixedThreadExecutorTest{
public static void main(String[] args) {
// TODO Auto-generated method stub
//創建一個可重用固定線程數的線程池
ExecutorService pool=Executors.newFixedThreadPool(2);
//創建實現了Runnable接口對象,Thread對象當然也實現了Runnable接口;
Thread t1=new TestThread();
Thread t2=new TestThread();
Thread t3=new TestThread();
Thread t4=new TestThread();
//將線程放到池中執行;
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
}
}
3.4.2. ScheduledThreadPool
public class scheduledThreadExecutorTest{
public static void main(String[] args) {
// TODO Auto-generated method stub
ScheduledThreadPoolExecutor exec =new ScheduledThreadPoolExecutor(1);
exec.scheduleAtFixedRate(new Runnable(){//每隔一段時間就觸發異常
@Override
public void run() {
// TODO Auto-generated method stub
//throw new RuntimeException();
System.out.println("===================");
}}, 1000, 5000, TimeUnit.MILLISECONDS);
exec.scheduleAtFixedRate(new Runnable(){//每隔一段時間打印系統時間,證明兩者是互不影響的
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(System.nanoTime());
}}, 1000, 2000, TimeUnit.MILLISECONDS);
}
}
1.5. 線程池及其核心代碼分析
ThreadPoolExecutor的完整構造方法的簽名是:
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) .
corePoolSize - 池中所保存的線程數,包括空閒線程。
maximumPoolSize-池中允許的最大線程數。
keepAliveTime - 當線程數大於核心時,此爲終止前多餘的空閒線程等待新任務的最長時間。
unit - keepAliveTime 參數的時間單位。
workQueue - 執行前用於保持任務的隊列。此隊列僅保持由 execute方法提交的 Runnable任務。
threadFactory - 執行程序創建新線程時使用的工廠。
handler - 由於超出線程範圍和隊列容量而使執行被阻塞時所使用的處理程序。
BlockingQueue的三種類型:
直接提交策略,也即SynchronousQueue。
它將任務直接提交給線程而不保持它們。在此,如果不存在可用於立即運行任務的線程,則試圖把任務加入隊列將失敗,因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時,此策略允許無界線程具有增長的可能性。
無界隊列策略,即LinkedBlockingQueue
使用無界隊列(例如,不具有預定義容量的 LinkedBlockingQueue)將導致在所有corePoolSize 線程都忙時新任務在隊列中等待。這樣,創建的線程就不會超過 corePoolSize。(因此,maximumPoolSize的值也就無效了。)當每個任務完全獨立於其他任務,即任務執行互不影響時,適合於使用無界隊列;例如,在 Web頁服務器中。這種排隊可用於處理瞬態突發請求,當命令以超過隊列所能處理的平均數連續到達時,此策略允許無界線程具有增長的可能性。
有界隊列,使用ArrayBlockingQueue
當使用有限的 maximumPoolSizes時,有界隊列(如 ArrayBlockingQueue)有助於防止資源耗盡,但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷:使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統資源和上下文切換開銷,但是可能導致人工降低吞吐量。如果任務頻繁阻塞(例如,如果它們是 I/O邊界),則系統可能爲超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小,CPU使用率較高,但是可能遇到不可接受的調度開銷,這樣也會降低吞吐量。
JDK中4個內置線程池的代碼:
newFixedThreadPool (int nThreads):固定大小線程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
newSingleThreadExecutor():單線程
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
newCachedThreadPool():無界線程池,可以進行自動線程回收
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
newScheduledThreadPool ():定時任務線程池
//預定執行而構建的固定線程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
1.6.擴展和增強線程池
1.6.1.回調接口
ThreadPoolExecutor對以下方法進行了空實現,所以需要開發者繼承ThreadPoolExecutor並且重寫實現以下方法。
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }
protected void terminated() { }
1.6.2. 拒絕策略
RejectedExecutionHandler接口提供了對於拒絕任務的處理的自定方法的機會。在ThreadPoolExecutor中已經默認包含了4中策略。
CallerRunsPolicy:線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制,能夠減緩新任務的提交速度。
AbortPolicy:處理程序遭到拒絕將拋出運行時RejectedExecutionException。
DiscardPolicy:不能執行的任務將被刪除
DiscardOldestPolicy:如果執行程序尚未關閉,則位於工作隊列頭部的任務將被刪除,然後重試執行程序(如果再次失敗,則重複此過程)
使用內置策略代碼示例:
ThreadPoolExecutor e=new ThreadPoolExecutor( 2, 3, 30, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
Executors.defaultThreadFactory() ,
//傳入要使用的策略
new ThreadPoolExecutor.CallerRunsPolicy());
使用自定義策略代碼示例:
ThreadPoolExecutor e= new ThreadPoolExecutor( 2, 3, 30, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
Executors.defaultThreadFactory() ,
new RejectedExecutionHandler(){
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
//do something
}
}
);
1.6.3.自定義ThreadFactory
public class CustomThreadFactory implements ThreadFactory
{
private int counter;
private String name;
private List<String> stats;
public CustomThreadFactory(String name)
{
counter = 1;
this.name = name;
stats = new ArrayList<String>();
}
@Override
public Thread newThread(Runnable runnable)
{
Thread t = new Thread(runnable, name + "-Thread_" + counter);
counter++;
stats.add(String.format("Created thread %d with name %s on %s \n", t.getId(), t.getName(), new Date()));
return t;
}
public String getStats()
{
StringBuffer buffer = new StringBuffer();
Iterator<String> it = stats.iterator();
while (it.hasNext())
{
buffer.append(it.next());
}
return buffer.toString();
}
}