之前對線程池中屬性：keepAliveTime比較模糊，而且看過之后過一段時間就會忘掉，于是就在此記錄一下。
keepAliveTime的jdk中的解釋為：
當線程數大于核心時，此為終止前多余的空閑線程等待新任務的最長時間。
說的讓人感覺比較模糊，總結一下大概意思為：比如說線程池中最大的線程數為50，而其中只有40個線程任務在跑，相當于有10個空閑線程，這10個空閑線程不能讓他一直在開著，因為線程的存在也會特別好資源的，所有就需要設置一個這個空閑線程的存活時間，這么解釋應該就很清楚了。
這樣以后忘記了就過來看看就OK了。
補充：線程池的狀態及KeepAliveTime參數
五個狀態
|
1
2
3
4
5
6
|
// runState is stored in the high-order bitsprivate static final int RUNNING = -1 << COUNT_BITS;private static final int SHUTDOWN = 0 << COUNT_BITS;private static final int STOP = 1 << COUNT_BITS;private static final int TIDYING = 2 << COUNT_BITS;private static final int TERMINATED = 3 << COUNT_BITS; |
循環getTask方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
/** * Performs blocking or timed wait for a task, depending on * current configuration settings, or returns null if this worker * must exit because of any of: * 1. There are more than maximumPoolSize workers (due to * a call to setMaximumPoolSize). * 2. The pool is stopped. * 3. The pool is shutdown and the queue is empty. * 4. This worker timed out waiting for a task, and timed-out * workers are subject to termination (that is, * {@code allowCoreThreadTimeOut || workerCount > corePoolSize}) * both before and after the timed wait. * * @return task, or null if the worker must exit, in which case * workerCount is decremented */ private Runnable getTask() { boolean timedOut = false; // Did the last poll() time out? retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } boolean timed; // Are workers subject to culling? for (;;) { int wc = workerCountOf(c); timed = allowCoreThreadTimeOut || wc > corePoolSize; //默認allowCoreThreadTimeOut為false，除非程序指定 //（1）當沒有超過核心線程時，默認allowCoreThreadTimeOut為false時 //timed值為false，始終break掉，不會銷毀線程 //（2）當超過核心線程數，默認allowCoreThreadTimeOut為false時 //timed值為true，如果超過最大值，則銷毀；如果timeout過，則銷毀 // 如果allowCoreThreadTimeOut為true，則timed始終為true if (wc <= maximumPoolSize && ! (timedOut && timed)) break; if (compareAndDecrementWorkerCount(c)) return null; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } try { Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } } |
線程池狀態大于SHUTDOWN值的兩種情況
1、調用shutdown方法
當線程池調用了shutdown方法，線程池的狀態會首先被設置為SHUTDOWN，然后遍歷線程池中所有線程，調用一次interrupt方法，如果在休眠中的線程將會激活，激活后的線程以及調用shutdown方法本身的線程都會嘗試去調用tryTerminate方法，該方法將判定如果線程池中所有記錄的線程數為0，則將線程狀態改為TERMINATED，這個值為3，將大于SHUTDOWN狀態值。
2、調用shutdownNow方法
當線程調用了shutdownNow方法后，首先將線程的狀態修改為STOP，這個狀態是大于SHUTDOWN值的，接下來它也會通過中斷激活線程，只是它來的更暴力一些，連加鎖和一些基本判斷都沒有，直接中斷；在調用tryTerminate之前會先清空阻塞隊列中所有的元素，這些元素被組裝為一個List列表作為shutdownNow方法的返回值。換句話說，沒有執行的任務在shutdownNow執行后的返回值中可以得到。在程序某些必要的情況下，可以通過線程池的isTerminating，isTerminated，isStopped，isShutdown來對線程做一些狀態判定。
KeepAliveTime參數
|
1
|
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) |
當阻塞隊列中沒有任務時，等待時間達到keepAliveTime毫秒值時就會被自動喚醒，而不會永遠地沉睡下去。
keepAliveTime，如果是通過newCachedThreadPool的話，默認是1分鐘超時，如果遇到前面所提到的瞬間沖擊，那么線程池數量將瞬間快速膨脹，而且這些瞬間膨脹的線程的生命周期最少在1分鐘以上。
如果設置了該參數，那么當timeout的時候，就return null，就會跳出循環，回收線程。
|
1
2
3
4
|
if (wc <= maximumPoolSize && ! (timedOut && timed)) break; if (compareAndDecrementWorkerCount(c)) return null; |
allowCoreThreadTimeout : 默認情況下核心線程不會退出，可通過將該參數設置為true，讓核心線程也退出。
默認的Executors工廠，只有newCachedThreadPool，timeout為60秒，出現timeout情況下，而且線程數超過了核心線程數，會銷毀銷毀線程。保持在corePoolSize數（如果是cached的，corePoolSize為0）。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/** * Timeout in nanoseconds for idle threads waiting for work. * Threads use this timeout when there are more than corePoolSize * present or if allowCoreThreadTimeOut. Otherwise they wait * forever for new work. */private volatile long keepAliveTime;/** * If false (default), core threads stay alive even when idle. * If true, core threads use keepAliveTime to time out waiting * for work. */private volatile boolean allowCoreThreadTimeOut; |
線程池最小是corePoolSize，最大是maximumPoolSize，除非設置了allowCoreThreadTimeOut和超時時間，這種情況線程數可能減少到0，最大可能是Integer.MAX_VALUE。
Core pool size is the minimum number of workers to keep alive(and not allow to time out etc) unless allowCoreThreadTimeOut is set, in which case the minimum is zero.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
/** * 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 <tt>execute</tt> 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); } |
超時timeout設置為0的話，表示不等待
|
1
2
3
|
public E poll(long timeout, TimeUnit unit) throws InterruptedException { return pollFirst(timeout, unit); } |
具體如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public E pollFirst(long timeout, TimeUnit unit) throws InterruptedException { long nanos = unit.toNanos(timeout); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { E x; while ( (x = unlinkFirst()) == null) { if (nanos <= 0) return null; nanos = notEmpty.awaitNanos(nanos); } return x; } finally { lock.unlock(); } } |
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持服務器之家。如有錯誤或未考慮完全的地方，望不吝賜教。
原文鏈接：https://blog.csdn.net/jianjun200607/article/details/44303561
