一、線程池工廠類Executors
java多線程開發時，常常用到線程池技術，JDK裏提供瞭如下Executors工廠類：
public class Executors {
//創建固定數量的線程：參數nThreads爲線程個數
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
//創建固定數量的線程：參數nThreads爲線程個數，參數threadFactory爲創建Thread對象的工程方法對象
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}
//創建單個工作線程
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
//創建單個工作線程: 參數threadFactory爲創建Thread對象的工程方法對象
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}
/**
* Creates a thread pool that creates new threads as needed, but
* will reuse previously constructed threads when they are
* available. These pools will typically improve the performance
* of programs that execute many short-lived asynchronous tasks.
* Calls to {@code execute} will reuse previously constructed
* threads if available. If no existing thread is available, a new
* thread will be created and added to the pool. Threads that have
* not been used for sixty seconds are terminated and removed from
* the cache. Thus, a pool that remains idle for long enough will
* not consume any resources. Note that pools with similar
* properties but different details (for example, timeout parameters)
* may be created using {@link ThreadPoolExecutor} constructors.
*
* @return the newly created thread pool
*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
/**
* Creates a thread pool that creates new threads as needed, but
* will reuse previously constructed threads when they are
* available, and uses the provided
* ThreadFactory to create new threads when needed.
* @param threadFactory the factory to use when creating new threads
* @return the newly created thread pool
* @throws NullPointerException if threadFactory is null
*/
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}
/**
* Creates a single-threaded executor that can schedule commands
* to run after a given delay, or to execute periodically.
* (Note however that if this single
* thread terminates due to a failure during execution prior to
* shutdown, a new one will take its place if needed to execute
* subsequent tasks.) Tasks are guaranteed to execute
* sequentially, and no more than one task will be active at any
* given time. Unlike the otherwise equivalent
* {@code newScheduledThreadPool(1)} the returned executor is
* guaranteed not to be reconfigurable to use additional threads.
* @return the newly created scheduled executor
*/
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
}
/**
* Creates a single-threaded executor that can schedule commands
* to run after a given delay, or to execute periodically. (Note
* however that if this single thread terminates due to a failure
* during execution prior to shutdown, a new one will take its
* place if needed to execute subsequent tasks.) Tasks are
* guaranteed to execute sequentially, and no more than one task
* will be active at any given time. Unlike the otherwise
* equivalent {@code newScheduledThreadPool(1, threadFactory)}
* the returned executor is guaranteed not to be reconfigurable to
* use additional threads.
* @param threadFactory the factory to use when creating new
* threads
* @return a newly created scheduled executor
* @throws NullPointerException if threadFactory is null
*/
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1, threadFactory));
}
/**
* Creates a thread pool that can schedule commands to run after a
* given delay, or to execute periodically.
* @param corePoolSize the number of threads to keep in the pool,
* even if they are idle
* @return a newly created scheduled thread pool
* @throws IllegalArgumentException if {@code corePoolSize < 0}
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
/**
* Creates a thread pool that can schedule commands to run after a
* given delay, or to execute periodically.
* @param corePoolSize the number of threads to keep in the pool,
* even if they are idle
* @param threadFactory the factory to use when the executor
* creates a new thread
* @return a newly created scheduled thread pool
* @throws IllegalArgumentException if {@code corePoolSize < 0}
* @throws NullPointerException if threadFactory is null
*/
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
}
二、線程池ThreadPoolExecutor類
在上述創建線程池的方法中基本上都用到了ThreadPoolExecutor類，這個類的七個參數詳細如下：
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
* parameters.
*
* @param corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @param maximumPoolSize the maximum number of threads to allow in the
* pool
* @param keepAliveTime when the number of threads is greater than
* the core, this is the maximum time that excess idle threads
* will wait for new tasks before terminating.
* @param unit the time unit for the {@code keepAliveTime} argument
* @param workQueue the queue to use for holding tasks before they are
* executed. This queue will hold only the {@code Runnable}
* tasks submitted by the {@code execute} method.
* @param threadFactory the factory to use when the executor
* creates a new thread
* @param handler the handler to use when execution is blocked
* because the thread bounds and queue capacities are reached
* @throws IllegalArgumentException if one of the following holds:<br>
* {@code corePoolSize < 0}<br>
* {@code keepAliveTime < 0}<br>
* {@code maximumPoolSize <= 0}<br>
* {@code maximumPoolSize < corePoolSize}
* @throws NullPointerException if {@code workQueue}
* or {@code threadFactory} or {@code handler} is null
*/
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
從源碼中可以看出，線程池的構造函數有7個參數，分別是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。
1、corePoolSize 線程池核心線程大小
線程池中會維護一個最小的線程數量，即使這些線程處理空閒狀態，他們也不會 被銷燬，除非設置了allowCoreThreadTimeOut。這裏的最小線程數量即是corePoolSize。
2、maximumPoolSize 線程池最大線程數量
一個任務被提交到線程池後，首先會緩存到工作隊列（後面會介紹）中，如果工作隊列滿了，則會創建一個新線程，然後從工作隊列中的取出一個任務交由新線程來處理，而將剛提交的任務放入工作隊列。線程池不會無限制的去創建新線程，它會有一個最大線程數量的限制，這個數量即由maximunPoolSize來指定。
3、keepAliveTime 空閒線程存活時間
一個線程如果處於空閒狀態，並且當前的線程數量大於corePoolSize，那麼在指定時間後，這個空閒線程會被銷燬，這裏的指定時間由keepAliveTime來設定
4、unit 空間線程存活時間單位
keepAliveTime的計量單位
5、workQueue 工作隊列
新任務被提交後，會先進入到此工作隊列中，任務調度時再從隊列中取出任務。jdk中提供了四種工作隊列：
- ①ArrayBlockingQueue
基於數組的有界阻塞隊列，按FIFO排序。新任務進來後，會放到該隊列的隊尾，有界的數組可以防止資源耗盡問題。當線程池中線程數量達到corePoolSize後，再有新任務進來，則會將任務放入該隊列的隊尾，等待被調度。如果隊列已經是滿的，則創建一個新線程，如果線程數量已經達到maxPoolSize，則會執行拒絕策略。
- ②LinkedBlockingQuene
基於鏈表的無界阻塞隊列（其實最大容量爲Interger.MAX），按照FIFO排序。由於該隊列的近似無界性，當線程池中線程數量達到corePoolSize後，再有新任務進來，會一直存入該隊列，而不會去創建新線程直到maxPoolSize，因此使用該工作隊列時，參數maxPoolSize其實是不起作用的。
- ③SynchronousQuene
一個不緩存任務的阻塞隊列，生產者放入一個任務必須等到消費者取出這個任務。也就是說新任務進來時，不會緩存，而是直接被調度執行該任務，如果沒有可用線程，則創建新線程，如果線程數量達到maxPoolSize，則執行拒絕策略。
- ④PriorityBlockingQueue
具有優先級的無界阻塞隊列，優先級通過參數Comparator實現。
6、threadFactory 線程工廠
創建一個新線程時使用的工廠，可以用來設定線程名、是否爲daemon線程等等
7、handler 拒絕策略
當工作隊列中的任務已到達最大限制，並且線程池中的線程數量也達到最大限制，這時如果有新任務提交進來，就會用到拒絕策略。
jdk中提供了4中拒絕策略：
- 調用者線程中直接執行:CallerRunsPolicy
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
- 拋出拒絕執行異常：AbortPolicy
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
- 直接丟棄任務(什麼都不做): DiscardPolicy
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
- 丟棄最早任務策略：DiscardOldestPolicy
拋棄進入隊列最早的那個任務，然後嘗試把這次拒絕的任務放入隊列
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
默認的拒絕策略是：
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();