ThreadPoolExecutor的corePoolSize、maximumPoolSize和poolSize

源码资源网 · 发表于昨天 12:11

ThreadPoolExecutor的corePoolSize、maximumPoolSize和poolSize
看两段源码：

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
　　　　 // Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
　　　　// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
　　　　final Thread t = w.thread;
if (t != null) {
　　　　final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}

复制代码

以上可以看出，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

		自动登录	找回密码
密码			立即注册

ThreadPoolExecutor的corePoolSize、maximumPoolSize和poolSize

相关帖子