线程池最核心的思想就是把资源放到一个池子中;每次使用都从里面获取,用完之后又放回池子供其他人使用。
通过线程复用机制,并对线程进行统一管理,具有以下优点:
-
1.降低系统资源消耗,通过复用已存在的线程,降低线程创建和销毁造成的消耗;
-
2.提高响应速度。当有任务到达时,无需等待新线程的创建便能立即执行;
-
3.提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗大量系统资源,还会降低系统的稳定性,使用线程池可以进行对线程进行统一的分配、调优和监控。
- 1.corePoolsize代表核心线程数,也就是正常情况下创建工作的线程数,这些线程创建后并不会消除,而是—种常驻线程
- 2.maxinumPoolsize 代表的是最大线程数,它与核心线程数相对应,表示最大允许被创建的线程数,
比如当前任务较多,将核心线程数都用完了,还无法满足需求时,此时就会创建新的线程,但是线程池内线程总数不会超过最大线程数 - 3.keepAliveTime、unit表示超出核心线程数之外的线程的空闲存活时间,也就是核心线程不会消除,但是超出核心线程数的部分线程如果空闲一定的时间则会被消除,我们可以通过setKeepAliveTime来设置空闲时间
- 4.workQueue用来存放待执行的任务,假设我们现在核心线程都已被使用,还有任务进来则全部放入队列,直到整个队列被放满但任务还再持续进入则会开始创建新的线程(大于核心线程数小于最大线程数的)
- 5.ThreadFactory 实际上是一个线程工厂,用来生产线程执行任务。我们可以选择使用默认的创建工厂,产生的线程都在同一个组内,拥有相同的优先级,且都不是守护线程。当然我们也可以选择自定义线程工厂,一般我们会根据业务来制定不同的线程工厂,设置线程名称
- 6.Handler任务拒绝策略,有两种情况,第一种是当我们调用shutdown等方法关闭线程池后,这时候即使线程池内部还有没执行完的任务正在执行,但是由于线程池已经关闭,我们再继续想线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数,线程池已经没有能力继续处理新提交的任务时,这是也就拒绝
-
- AbortPolicy (默认的:队列满了,就丢弃任务抛出异常!);
-
- CallerRunsPolicy(哪来的回哪去? 谁叫你来的,你就去哪里处理)只会用调用者所在线程来运行任务,也就是说任务不会进入线程池;
-
- DiscardOldestPolicy (尝试将最早进入队列的任务删除,尝试加入新任务);
-
- DiscardPolicy (直接丢弃掉新提交的任务,队列满了任务也会丢弃,不抛出异常)。
总共包含以下 7 种(其中 6 种是通过 Executors 创建的, 1 种是通过
ThreadPoolExecutor 创建的):
- 1.Executors.newFixedThreadPool:创建⼀个固定⼤⼩的线程池,可控制并发的线程数,超出的线程会在队列中等待;
- 2.Executors.newCachedThreadPool:创建⼀个可缓存的线程池,若线程数超过处理所需,缓存⼀段时间后会回收,若线程数不够,则新建线程;
- 3.Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执⾏顺序;
- 4.Executors.newScheduledThreadPool:创建⼀个可以执⾏延迟任务的线程池;
- 5.Executors.newSingleThreadScheduledExecutor:创建⼀个单线程的可以执⾏延迟任务的线程池;
- 6.Executors.newWorkStealingPool:创建⼀个抢占式执⾏的线程池(任务执⾏顺序不确定)【JDK1.8 添加】。
- 7.ThreadPoolExecutor:最原始的创建线程池的⽅式,它包含了 7 个参数可供设置,后⾯会详细讲。
在阿里的规范中是不允许使用Executors的方式来创建的,而是通过ThreadPoolExecutor的方式来创建。这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。
说明:Executors各个方法的弊端:
1)newFixedThreadPool和newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。
2)newCachedThreadPool和newScheduledThreadPool:
主要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至OOM。
源码分析通常我们在使用的时候都是execute或者submit的方式。submit最后也是调用execute方法。所以核心方法就是execute.
在具体分析之前先了解下线程池中所定义的状态,这些状态都和线程的执行密切相关
private 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;
- RUNNING 自然是运行状态,指可以接受任务执行队列里的任务
- SHUTDOWN 指调用了 shutdown() 方法,不再接受新任务了,但是队列里的任务得执行完毕。
- STOP 指调用了 shutdownNow() 方法,不再接受新任务,同时抛弃阻塞队列里的所有任务并中断所有正在执行任务。
- TIDYING 所有任务都执行完毕,在调用 shutdown()/shutdownNow() 中都会尝试更新为这个状态。
- TERMINATED 终止状态,当执行 terminated() 后会更新为这个状态。
- 1.获取当前线程池状态
- 2.如果当前线程数量小于 coreSize(核心线程数)时创建一个新的线程运行。
- 3.如果当前线程池是运行状态并且放入队列成功(队列没有满)
- 4.双重检查,再次获取线程状态;如果当前线程不是RUNNING状态,说明执行过shutdown命令,这个时候需要把刚刚加入队列的队列移除,同时执行拒绝策略。
- 5.如果当前线程池为空就新创建一个线程并执行。
- 6.到这就两种情况
-
- 线程池没有在运行
-
- 线程池在运行,但是队列满了
-
- 尝试新建线程,如果失败就执行拒绝策略。
addWorker方法源码:其实就做了两件事。
- 1)采用循环CAS操作来将线程数加1;
- 2)新建一个线程并启用。
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 (;;) {
// 获取worker(工作线程)数目
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 到这里说明可以创建工作线程了,先把工作线程数递增(加1)
// 如果工作线程数递增成功,则通过break retry 可以跳出最外层的for循环
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) {
//worker的添加必须得是串行的,因此需要加锁
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 在持有锁的情况下重新check线程池状态,防止在创建worker阶段或者获取锁之前的逻辑执行时,状态发生变化。
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// 检查一下worker对象中的线程对象是否已经执行了start方法
// 如果已经执行了,说明状态不对,抛出线程状态异常。
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
// 获取工作线程集合大小
int s = workers.size();
// 这个largestPoolSize是统计线程的生命周期内曾经达到过的工作线程数的最大值
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 如果成功的添加了工作线程
if (workerAdded) {
//启动工作线程
//这个方法最终会执行Worker对象的run方法,内部又会调用runWorker方法。
//达到的效果就是,先处理firstTask,处理完之后再去队列中获取其他任务。
t.start();
workerStarted = true;
}
}
} finally {
//失败时做什么清理工作?
//1.释放令牌
//2.将当前worker清理出workers集合
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
该方法就是创建一个Worker线程并启用,Worker继承自AQS,具有锁的功能,实现了Runable接口,又有线程的功能。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
//线程池中正真运行的线程。通过我们指定的线程工厂创建而来
final Thread thread;
//线程包装的任务。thread 在run时主要调用了该任务的run方法
Runnable firstTask;
//记录当前线程完成的任务数
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
//利用我们指定的线程工厂创建一个线程
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
如何配置线程参数
线程池肯定不是越大越好,通常需要根据实际任务的性质来确定
CPU密集型任务计算任务
经验公式(N+1),理论上设置为N的话性能是最优的,因为没有任何线程切换的开销,同时又可以让每一个cpu都忙起来,没有任何的资源浪费。如果某一个线程突然出现暂停或者中断。那么cpu就会有一个核心出现空闲状态。所以一般会设置为N+1,多出来的一个cpu就可以充分利用cpu的空闲时间。
IO密集型任务操作数据库的任务
经验公式(2N)线程处理io的话是不占用cpu的,所以处理io的这段时间这个线程的cpu资源可以交给其它线程去使用,因此处理io密集型任务可以多配置一些cpu
当然这些都是经验值,最好的方式还是根据实际情况测试得出最佳配置。



