预备知识——线程池的创建、构造方法的参数
//线程池的全参构造方法
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler);
还有几个非全参构造方法,如果不是使用的全参构造,未传入的参数会被定义为默认值:
//各参数默认值
ThreadFactory:Executors.defaultThreadFactory()
RejectedExecutionHandler: defaultHandler = new AbortPolicy();
//关于DefaultThreadFactory的详细代码
private static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
@SuppressWarnings("removal")
//SecurityManager是一个允许应用实现一种安全策略的类。
//应用在执行一个安全或敏感的操作之前,可以明确此操作是否在一个安全的上下文中被执行
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
//通过该方法提供创建新线程的功能,创建的线程都是【非守护线程】,优先级都是NORM_PRIORITY
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
对于ThreadFactory,当选择自己传入ThreadFactory参数时,通过提供不同的 ThreadFactory,我们可以更改线程的名称、线程组、优先级、是否设置为守护线程等。
对于RejectedExecutionHandler拒绝策略,共有四种拒绝策略:
- CallerRunsPolicy:使用调用者线程执行被拒绝任务的run()方法;
- AbortPolicy:拒绝执行任务,并抛出RejectedExecutionException;
- DiscardPolicy:拒绝执行任务,什么都不做;
- DiscardOldestPolicy:把最早进入工作队列的任务移除,尝试把这次的任务放入队列中。
线程池的execute()方法
源码:
/**
主线程控制状态ctl,是一个AtomicInteger对象,包含两个字段。
workCount指示线程的有效数量
runState指示其是否正在运行、关闭等,应该指示的是线程的状态
为了将它们打包成一个int变量,将workCount限制为2^29-1个线程,也就是低29位表示workCount,高3位表示runState
**/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//接收新任务,并且处理队列中的任务
private static final int RUNNING = -1 << COUNT_BITS;
//不接收新任务,但处理队列中的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;
//不接收新任务,不处理队列中的任务,并中断正在执行的任务
private static final int STOP = 1 << COUNT_BITS;
//所有任务都已终止,workCount为零,转换到TIDYING的线程将执行terminated方法??(线程转换,这个不是线程池的状态码??)
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
private static int ctlOf(int rs, int wc) { return rs | wc; }
private static int runStateOf(int c) { return c & ~COUNT_MASK; }
private static int workerCountOf(int c) { return c & COUNT_MASK; }
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//获取线程个数workCount和状态runState
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//线程数大于等于核心线程数时,判断当前状态是否为Running状态(Running状态可以处理任务,也可以处理干工作队列中的任务)
//是Running状态将任务放入工作队列中,如果工作队列满则会失败
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//线程数大于核心线程数且工作队列已满,添加一个非核心工作线程执行,添加失败则执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
// Check if queue empty only if necessary.
//------------------线程池状态的判断---------------------------//
//c >= SHUTDOWN,代表当前线程池状态为:SHUTDOWN、STOP、TIDYING、TERMINATED,线程池状态异常
//但是SHUTDOWN有些特殊,在这个状态下不会接收新任务,正在处理的任务正常进行,阻塞队列的任务也会执行
//所以如果当前的状态时SHUTDOWN状态,并且阻塞队列不为空,且新任务为空,需要新建一个非核心工作线程去执行任务
//如果不是上述情况返回false
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
//-----------------工作线程数量判断---------------------------//
for (;;) {
//创建核心线程时,判断当前线程数量是否大于等于corePoolSize,是则返回false
//创建非核心线程时,判断当前线程数量是否大于等于maximumPoolSize,是则返回false
//不是上述情况继续向下执行
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
//使用CAS增加线程数量,如果成功,跳出循环,继续向下执行
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateAtLeast(c, SHUTDOWN))
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 c = ctl.get();
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
workers.add(w);
workerAdded = true;
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
调用线程池的execute()方法后可能会出现以下几种情况:
- 传入的Runnable实例为null,直接返回空指针异常;
- 如果线程数量 < corePoolSize,即核心线程数量;
- 线程数量 >= corePoolSize,把任务放入阻塞队列中;
- 如果添加阻塞队列失败,尝试添加非核心线程处理该任务;
- 如果添加非核心线程失败,执行拒绝策略。
未完待续......