线程的消耗
1、其实 Java 中的线程模型是基于操作系统原生线程模型实现的,也就是说 Java 中的线程其实是基于内核线程实现的,线程的创建,析构与同步都需要进行系统调用,而系统调用需要在用户态与内核中来回切换,代价相对较高,线程的生命周期耗时包括「线程创建时间」,「线程执行任务时间」,「线程销毁时间」,创建和销毁都需要导致系统调用;
2、每个 Thread 都需要有一个内核线程的支持,也就意味着每个 Thread 都需要消耗一定的内核资源(如内核线程的栈空间),因此能创建的 Thread 是有限的;
3、线程多了,导致不可忽视的上下文切换开销。
由此可见线程的创建消耗代价是昂贵的,所以必须以线程池的形式来管理这些线程,在线程池中合理设置线程大小和管理线程,以达到以合理的创建线程大小以达到最大化收益,最小化风险的目的,对于开发人员来说,要完成任务不用关心线程如何创建,如何销毁,如何协作,只需要关心提交的任务何时完成即可,对线程的调优,监控等这些细枝末节的工作通通交给线程池来实现。
线程池类关系
先来看一张线程池的继承类关系图:
- 最顶层的是
Executor
接口,源码里只有execute
一个声明方法; Executor
接口的子类是ExecutorService
接口,源码中声明了shutdown
、shutdownNow
、isShutdown
、submit
等方法;Executor
接口有两个子类,一个是AbstractExecutorService
抽象类,一个是ScheduledExecutorService
接口;AbstractExecutorService
抽象类是ThreadPoolExecutor
类和ForkJoinPool
类的父类;ScheduledExecutorService
接口的实现类是ScheduledThreadPoolExecutor
,ScheduledThreadPoolExecutor
类又是ThreadPoolExecutor
类的子类;- 最后就是上一篇中所说的6种线程池的创建方式和
ThreadPoolExecutor
创建方式。
线程池工作原理
线程池运行机制主要由工作线程、工作队列、拒绝策略组成,其工作原理如下所示:
-
如果此时线程池中的线程数量小于
corePoolSize
,无论线程池中的线程是否处于空闲状态,也会创建新的线程来处理被添加的任务; -
如果此时线程池中的线程数量等于
corePoolSize
,但是阻塞队列workQueue
未满,那么任务被放入阻塞队列; -
如果此时线程池中的线程数量大于等于
corePoolSize
,阻塞队列workQueue
已满,并且线程池中的线程数量小于maximumPoolSize
,则会创建新的线程来处理被添加的任务; -
如果此时线程池中的线程数量大于
corePoolSize
,阻塞队列workQueue
已满,并且线程池中的线程数量等于maximumPoolSize
,那么通过handler
所指定的拒绝策略来处理此任务; -
当线程池中的线程数量比
corePoolSize
数量要多时,如果某线程空闲时间超过keepAliveTime
,线程将被终止。这样,线程池可以动态的调整池中的线程数。
从线程池工作原理中可以得知:
-
提交任务优先级为核心线程
corePoolSize
> 任务队列workQueue
> 最大线程maximumPoolSize
,如果三者都满了,使用handler处理被拒绝的任务; -
当
workQueue
使用的是无界限队列时(比如new LinkedBlockingQueue()
,或者new ArrayBlockingQueue(Integer.MAX_VALUE)
;),任务可以一直向队列中添加,maximumPoolSize
参数就变的无意义了。比如newFixedThreadPool
和newSingleThreadExecutor
这两种线程池的工作队列是LinkedBlockingQueue
,而maximumPoolSize
和corePoolSize
相等。 -
使用
SynchronousQueue
队列时由于该队列没有容量的特性(特点:内部没有容器,一个生产线程,当它生产产品(即put的时候),如果当前没有人想要消费产品(即当前没有线程执行take),此生产线程必须阻塞,等待一个消费线程调用take操作,take操作将会唤醒该生产线程,同时消费线程会获取生产线程的产品,队列操作时offer为非阻塞,take为阻塞,put也为阻塞操作
),所以不会对任务进行排队,如果线程池中没有空闲线程,会立即创建一个新线程来接收这个任务,故而maximumPoolSize
要设置大一点;比如:
newCachedThreadPool
中使用的是SynchronousQueue
,任务到来,有空闲线程则使用空闲线程,无空闲线程则创建。所以称之为缓存线程,而它的maximumPoolSize
设置的是Integer.MAX_VALUE
; -
核心线程和最大线程数量相等时
keepAliveTime
无作用,因为只有当前运行线程数大于corePoolSize
时,才会判断当有空闲线程时并且到了keepAliveTime
的时间,终止线程。 -
线程池能处理的任务数 =
corePoolSize
+ 阻塞队列容量 + 创建的工作线程(maximumPoolSize
-corePoolSize
),比如corePoolSize
为2,阻塞队列为5,maximumPoolSize
为10,当前要创建的线程为16,则corePoolSize
先运行2个核心线程,剩下的放入阻塞队列5个,然后再创建(10-2)8个工作线程,总共运行线程是 2 + 5+ 8 = 15,剩下最后一个线程则由拒绝策略处理。
线程池源码解析
《线程池的使用方式》一文中了解了线程池的创建方式,这里开始分析线程池的执行方法execute
:
public void execute(Runnable command) {
......
// 1.获取线程运行状态或数量
int c = ctl.get();
// 2.如果线程池线程数量小于核心线程数,则创建新线程
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 3、如果线程数量大于等于corePoolSize,并且
// 如果线程池是运行状态,则将线程添加到工作队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 4、再次检测线程是否是运行状态,因为执行入队操作后,线程有可能不是运行状态了
// 如果线程池不在运行状态,则移除线程,并执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 5、如果线程是运行状态,线程数量是0,则开启新线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 6、如果添加worker失败,则执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
1、获取线程运行状态或数量;
2、判断工作线程数量如果小于核心线程,则开启核心线程,第二个参数传true表示是不是核心线程;
private boolean addWorker(Runnable firstTask, boolean core)
3、如果线程数量大于等于corePoolSize
,并且如果线程池是运行状态,则将线程添加到工作队列;这里有必须了解一下线程池的几种状态:
线程池状态管理
通过下面源码得知,线程池使用AtomicInteger
类型(AtomicInteger
是一个提供原子操作的Integer类,通过线程安全的方式操作加减,十分适合高并发情况下的使用)的ctl
变量记录线程池的状态和线程池中的线程数量,初始化的时候传入ctlOf(RUNNING, 0)
的执行结果,通过函数可以发现返回RUNNING
的值,即111 00000000000000000000000000000
,这里有32位,低 29 位表示线程数量, 29 位最大可以表示 (2^29)-1 (536870911)个线程数,,高 3 位用来表示线程池的状态,3 位可以表示 8 个线程池的状态,而线程池总共只有五个状态。
public class ThreadPoolExecutor extends AbstractExecutorService {
// ctl用了记录线程池的状态和线程池中的线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 32 - 3 = 29
private static final int COUNT_BITS = Integer.SIZE - 3;
// 表示29左移1位,再减1,容量是1 1111 1111 1111 1111 1111 1111 1111,十进制是 2^29-1 = 536870911
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// RUNNING,-1左移29位 111 00000000000000000000000000000 29个0
private static final int RUNNING = -1 << COUNT_BITS;
// SHUTDOWN,0左移29位,000 00000000000000000000000000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
// STOP,1左移29位 001 00000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
// TIDYING, 2左移29位 010 00000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
// TERMINATED,3左移29位 011 00000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
// 线程状态
private static int runStateOf(int c) {
return c & ~CAPACITY; }
// 线程数量
private static int workerCountOf(int c) {
return c & CAPACITY; }
// 初始化ctl
private static int ctlOf(int rs, int wc) {
return rs | wc; }
移位运算符
<< : 左移运算符,num << n, 相当于num左移n位;
>> : 右移运算符,num >> n, 相当于num右移n位;
可以测试一下输出:
// 测试
int COUNT_BITS = Integer.SIZE - 3; // 32 - 3 = 29
Log.e(TAG, "COUNT_BITS: " + COUNT_BITS);
Log.e(TAG, "COUNT_BITS toBinaryString: " + Integer.toBinaryString(COUNT_BITS));
int CAPACITY = (1 << COUNT_BITS) - 1; // 1左移29位再减1,11111111111111111111111111111
Log.e(TAG, "CAPACITY: " + CAPACITY);
Log.e(TAG, "CAPACITY: " + Integer.toBinaryString(CAPACITY));
int RUNNING = -1 << COUNT_BITS; // -1左移29位 111 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "RUNNING: " + Integer.toBinaryString(RUNNING));
int SHUTDOWN = 0 << COUNT_BITS; // 0 左移29位 000 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "SHUTDOWN: " + Integer.toBinaryString(SHUTDOWN));
int STOP = 1 << COUNT_BITS; // 1左移29位 001 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "STOP: " + Integer.toBinaryString(STOP));
int TIDYING = 2 << COUNT_BITS; // 2左移29位 010 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "TIDYING: " + Integer.toBinaryString(TIDYING));
int TERMINATED = 3 << COUNT_BITS; // 3左移29位 011 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "TERMINATED: " + Integer.toBinaryString(TERMINATED));
线程池状态
- RUNNING:接受新任务并且处理阻塞队列里的任务;
- SHUTDOWN:拒绝新任务但是处理阻塞队列里的任务;
- STOP:拒绝新任务并且抛弃阻塞队列里的任务,同时会中断正在处理的任务;
- TIDYING:所有任务都执行完(包含阻塞队列里面任务)当前线程池活动线程为 0,将要调用
terminated
方法; - TERMINATED:终止状态,terminated方法调用完成以后的状态。
线程池状态转换
1.RUNNING -> SHUTDOWN:显式调用 shutdown()
方法,或者隐式调用了 finalize()
,它里面调用了 shutdown()
方法。
2.RUNNING or SHUTDOWN -> STOP:显式调用 shutdownNow()
方法时候。
3.SHUTDOWN -> TIDYING:当线程池和任务队列都为空的时候。
4.STOP -> TIDYING:当线程池为空的时候。
5.TIDYING -> TERMINATED:当 terminated()
方法执行完成时候。
4、再次检测线程是否是运行状态,因为执行入队操作后,线程有可能不是运行状态了,如果线程池不在运行状态,则移除线程,并执行拒绝策略;
5、如果线程是运行状态,线程数量是0,则开启新线程;
6、如果添加worker失败,则执行拒绝策略,拒绝策略实际调用了RejectedExecutionHandler
的rejectedExecution
方法:
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
其实execute
方法中最主要的是addWorker
方法,下面分析一下Worker的处理流程:
线程池中的Worker
线程池为了掌握线程的状态并维护线程的生命周期,设计了线程池内的工作线程Worker。Worker首先继承了AbstractQueuedSynchronizer
父类(Java并发编程核心在于 java.concurrent.util 包而juc当中的大多数同步器实现都是围绕着共同的基础行为,比如等待队列、条件队列、独占获取、共享获取等,而这个行为的抽象就是基于 AbstractQueuedSynchronizer 简称AQS,AQS定义了一套多线程访问共享资源的同步器框架,是一个依赖状态(state)的同步器。子类们必须定义改变state变量的protected方法,这些方法定义了state是如何被获取或释放的
),并实现了Runnable
接口,实现了Runnable
接口。
// 此处可以看出 worker 既是一个 Runnable 任务,也实现了 AQS(实际上是用 AQS 实现了一个独占锁,这样由于 worker 运行时会上锁,执行 shutdown,setCorePoolSize,setMaximumPoolSize等方法时会试着中断线程(interruptIdleWorkers) ,在这个方法中断方法中会先尝试获取 worker 的锁,如果不成功,说明 worker 在运行中,此时会先让 worker 执行完任务再关闭 worker 的线程,实现优雅关闭线程的目的)
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
// 实际执行任务的线程
final Thread thread;
// 如果当前线程数少于核心线程数,创建线程并将提交的任务交给 worker处理,此时 firstTask 即为此提交的任务,如果 worker 从 workQueue 中获取任务,则 firstTask 为空
Runnable firstTask;
// 统计完成的任务数
volatile long completedTasks;
Worker(Runnable firstTask) {
// 初始化为 -1,这样在线程运行前(调用runWorker)禁止中断,在 interruptIfStarted() 方法中会判断 getState()>=0
setState(-1);
this.firstTask = firstTask;
// 根据线程池的 threadFactory 创建一个线程,将 worker 本身传给线程(因为 worker 实现了 Runnable 接口)
this.thread = getThreadFactory().newThread(this);
}
public void run() {
// thread 启动后会调用此方法
runWorker(this);
}
// 1 代表被锁住了,0 代表未锁
protected boolean isHeldExclusively() {
return getState() != 0;
}
// 尝试获取锁
protected boolean tryAcquire(int unused) {
// 从这里可以看出它是一个独占锁,因为当获取锁后,cas 设置 state 不可能成功,这里我们也能明白上文中将 state 设置为 -1 的作用,这种情况下永远不可能获取得锁,而 worker 要被中断首先必须获取锁
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 尝试释放锁
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
set