ThreadPoolExecutor的corePoolSize、maximumPoolSize和poolSize

看两段源码：

  1 public ThreadPoolExecutor(int corePoolSize,
  2
  3         int maximumPoolSize,
  4
  5         long keepAliveTime,
  6
  7         TimeUnit unit,
  8
  9         BlockingQueue<Runnable> workQueue,
 10
 11         ThreadFactory threadFactory,
 12
 13         RejectedExecutionHandler handler) {
 14
 15         if (corePoolSize < 0 ||
 16
 17         maximumPoolSize <= 0 ||
 18
 19         maximumPoolSize < corePoolSize ||
 20
 21         keepAliveTime < 0)
 22
 23         throw new IllegalArgumentException();
 24
 25         if (workQueue == null || threadFactory == null || handler == null)
 26
 27         throw new NullPointerException();
 28
 29         this.acc = System.getSecurityManager() == null ?
 30
 31         null :
 32
 33         AccessController.getContext();
 34
 35         this.corePoolSize = corePoolSize;
 36
 37         this.maximumPoolSize = maximumPoolSize;
 38
 39         this.workQueue = workQueue;
 40
 41         this.keepAliveTime = unit.toNanos(keepAliveTime);
 42
 43         this.threadFactory = threadFactory;
 44
 45         this.handler = handler;
 46
 47         }
 48
 49 private boolean addWorker(Runnable firstTask, boolean core) {
 50
 51         retry:
 52
 53         for (;;) {
 54
 55         int c = ctl.get();
 56
 57         int rs = runStateOf(c);
 58
 59　　　　 // Check if queue empty only if necessary.
 60
 61         if (rs >= SHUTDOWN &&
 62
 63         ! (rs == SHUTDOWN &&
 64
 65         firstTask == null &&
 66
 67         ! workQueue.isEmpty()))
 68
 69         return false;
 70
 71         for (;;) {
 72
 73         int wc = workerCountOf(c);
 74
 75         if (wc >= CAPACITY ||
 76
 77         wc >= (core ? corePoolSize : maximumPoolSize))
 78
 79         return false;
 80
 81         if (compareAndIncrementWorkerCount(c))
 82
 83         break retry;
 84
 85         c = ctl.get(); // Re-read ctl
 86
 87         if (runStateOf(c) != rs)
 88
 89         continue retry;
 90
 91 　　　　// else CAS failed due to workerCount change; retry inner loop
 92
 93         }
 94
 95         }
 96
 97         boolean workerStarted = false;
 98
 99         boolean workerAdded = false;
100
101         Worker w = null;
102
103         try {
104
105         w = new Worker(firstTask);
106
107 　　　　final Thread t = w.thread;
108
109         if (t != null) {
110
111 　　　　final ReentrantLock mainLock = this.mainLock;
112
113         mainLock.lock();
114
115         try {
116
117 // Recheck while holding lock.
118
119 // Back out on ThreadFactory failure or if
120
121 // shut down before lock acquired.
122
123         int rs = runStateOf(ctl.get());
124
125         if (rs < SHUTDOWN ||
126
127         (rs == SHUTDOWN && firstTask == null)) {
128
129         if (t.isAlive()) // precheck that t is startable
130
131         throw new IllegalThreadStateException();
132
133         workers.add(w);
134
135         int s = workers.size();
136
137         if (s > largestPoolSize)
138
139         largestPoolSize = s;
140
141         workerAdded = true;
142
143         }
144
145         } finally {
146
147         mainLock.unlock();
148
149         }
150
151         if (workerAdded) {
152
153         t.start();
154
155         workerStarted = true;
156
157         }
158
159         }
160
161         } finally {
162
163         if (! workerStarted)
164
165         addWorkerFailed(w);
166
167         }
168
169         return workerStarted;
170
171         }

以上可以看出，ThreadPoolExecutor的主要参数有：corePoolSize , maximumPoolSize , keepAliveTime ,workQueue,threadFactory,handler ,对于几个参数，我们该如何理解呢？

先看看这几个参数：

corePoolSize :

顾名思义，核心线程大小，即在没有任务需要执行的时候线程池的大小，并且只有在工作队列满了的情况下才会创建超出这个数量的线程；

maximuxPoolSize :

线程池中允许创建的最大线程数大小；

poolSize :

当前线程池中线程的数量，当改值为0的时候，意味着没有任何线程，线程池会终止；同时，poolSize不会超过maximumPoolSize;

看看官方解释：

Queuing

Any BlockingQueue may be used to transfer and hold submitted tasks. The use of this queue interacts with pool sizing:

● If fewer than corePoolSize threads are running, the Executor always prefers adding a new thread rather than queuing.

● If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread.

● If a request cannot be queued, a new thread is created unless this would exceed maximumPoolSize, in which case, the task will be rejected.

理解：

1、如果当前线程池的线程数还没有达到核心线程数大小，即 poolSize < corePoolSize ,无论是否有空闲的线程，系统回新增一个线程来处理新提交的任务；

2、如果当前线程池的线程数大于或者等于核心线程数大小，即 poolSize >= corePoolSize,且任务队列未满时，将提交的任务提交到阻塞队列中，等待处理workQueue.offer(command);

3、如果当前线程池的线程数大于或者等于核心线程数大小，即 poolSize >= corePoolSize,且任务队列已满时，分以下两种情况：

3.1、poolSize < maximumPoolSize ，新增线程来处理任务；

3.2、poolSize = maximuxPoolSize ,意味中线程池的处理能力已经达到极限，此时会拒绝增加新的任务，至于如何拒绝，取决于RejectedExecutionHandler