516
ThreadPool 線程池的使用
https://royzhou1985.iteye.com/blog/789934
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolTest {
BlockingQueue<Runnable> workQueue;
ThreadPoolExecutor pool;
public ThreadPoolTest() {
this.workQueue = new LinkedBlockingQueue<Runnable>();
this.pool = new ThreadPoolExecutor(5, 5, 600, TimeUnit.SECONDS, workQueue);
}
public static void main(String[] args) throws InterruptedException {
new ThreadPoolTest().process();
}
public void process() throws InterruptedException {
for(int i=0; i<100; i++) {
System.out.println("start putting task " + (i+1));
dispatchTask(i);
}
/**
* wait for all task to be completed
*/
while(workQueue.size()>1) {
System.out.println("there is still some task unfinish,sleep 5 seconds and check again");
Thread.sleep(5000);
}
System.out.println("finish all task");
pool.shutdown();
//if all task still not finish, sleep 5 seconds and check again
while(!pool.isTerminated()) {
pool.awaitTermination(5, TimeUnit.SECONDS);
}
}
public void dispatchTask(int index) throws InterruptedException {
/**
* most task in the waiting queue is 10
* if more than 10 then sleep 5 seconds
* and check the work queue size again
*/
while(workQueue.size() > 20) {
Thread.sleep(5000);
}
pool.submit(new MyTask(index));
}
}
class MyTask implements Runnable {
private int i;
public MyTask(int i) {
this.i = i;
}
public void run() {
System.out.println("Task " + (i+1) + " is processing!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
一、簡介
線程池類為 java.util.concurrent.ThreadPoolExecutor，常用構造方法為：
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
corePoolSize： 線程池維護線程的最少數量
maximumPoolSize：線程池維護線程的最大數量
keepAliveTime： 線程池維護線程所允許的空閑時間
unit： 線程池維護線程所允許的空閑時間的單位
workQueue： 線程池所使用的緩衝隊列
handler： 線程池對拒絕任務的處理策略
常用方法：
submit 提交一個Task去執行，並返回執行結果
awaitTermination 當執行線程中斷、超時，或調用了shutdown方法後，阻塞直到所有的Task都執行結束。
shutdown 關閉所有執行過的Task,並不再接收新線程
isTerminated 如果所有Task都關閉則返回True,前提是調用過shutdown或shutdownNow
一個任務通過 execute(Runnable)方法被添加到線程池，任務就是一個 Runnable類型的對象，任務的執行方法就是 Runnable類型對象的run()方法。
當一個任務通過execute(Runnable)方法欲添加到線程池時：
如果此時線程池中的數量小於corePoolSize，即使線程池中的線程都處於空閑狀態，也要創建新的線程來處理被添加的任務。
如果此時線程池中的數量等於 corePoolSize，但是緩衝隊列 workQueue未滿，那麼任務被放入緩衝隊列。
如果此時線程池中的數量大於corePoolSize，緩衝隊列workQueue滿，並且線程池中的數量小於maximumPoolSize，建新的線程來處理被添加的任務。
如果此時線程池中的數量大於corePoolSize，緩衝隊列workQueue滿，並且線程池中的數量等於maximumPoolSize，那麼通過 handler所指定的策略來處理此任務。
也就是：處理任務的優先級為：
核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。
當線程池中的線程數量大於 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態的調整池中的線程數。
unit可選的參數為java.util.concurrent.TimeUnit中的幾個靜態屬性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue
handler有四個選擇：
ThreadPoolExecutor.AbortPolicy()
拋出java.util.concurrent.RejectedExecutionException異常
ThreadPoolExecutor.CallerRunsPolicy()
重試添加當前的任務，他會自動重複調用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
拋棄舊的任務
ThreadPoolExecutor.DiscardPolicy()
拋棄當前的任務
說明：
1、在這段程序中，一個任務就是一個Runnable類型的對象，也就是一個ThreadPoolTask類型的對象。
2、一般來說任務除了處理方式外，還需要處理的數據，處理的數據通過構造方法傳給任務。
3、在這段程序中，main()方法相當於一個殘忍的領導，他派發出許多任務，丟給一個叫 threadPool的任勞任怨的小組來做。
這個小組裏麵隊員至少有兩個，如果他們兩個忙不過來，任務就被放到任務列表裏麵。
如果積壓的任務過多，多到任務列表都裝不下(超過3個)的時候，就雇傭新的隊員來幫忙。但是基於成本的考慮，不能雇傭太多的隊員，至多隻能雇傭 4個。
如果四個隊員都在忙時，再有新的任務，這個小組就處理不了了，任務就會被通過一種策略來處理，我們的處理方式是不停的派發，直到接受這個任務為止(更殘忍！嗬嗬)。
因為隊員工作是需要成本的，如果工作很閑，閑到 3SECONDS都沒有新的任務了，那麼有的隊員就會被解雇了，但是，為了小組的正常運轉，即使工作再閑，小組的隊員也不能少於兩個。
4、通過調整 produceTaskSleepTime和 consumeTaskSleepTime的大小來實現對派發任務和處理任務的速度的控製，改變這兩個值就可以觀察不同速率下程序的工作情況。
5、通過調整4中所指的數據，再加上調整任務丟棄策略，換上其他三種策略，就可以看出不同策略下的不同處理方式。
6、對於其他的使用方法，參看jdk的幫助，很容易理解和使用。
*/
最後更新：2017-04-03 18:52:11