分析线程池的源码之前,先要知道线程池的作用,以下这几点引用自《码出高效-Java开发手册》:
1、利用线程池管理并复用线程、控制最大并发数等。
2、实现任务线程队列缓存策略和拒绝机制。
3、实现某些与时间相关的功能,如定时执行、周期执行等。
4、隔离线程环境。比如,交易服务和搜索服务在同一台服务器上,分别开启两个线程池,交易线程的资源消耗明显要大;因此,通过配置独立的线程池 ,将较慢的交易服务与搜索服务隔离开,避免各服务线程相互影响。
那么自然我们使用线程池的目的也就很显然了:
1、线程是稀缺资源,不能频繁的创建。
2、解耦作用;线程的创建与执行完全分开,方便维护。
3、应当将其放入一个池子中,可以给其他任务进行复用。
在看线程池源码之前,一张图先大致记住下实线箭头表示extends 虚线箭头表示 implements:
JDK1.5之后推出了相关的线程池的API,我们常见的创建线程池的方式有以下几种:
- Executors.newCachedThreadPool():无限线程池。
- Executors.newFixedThreadPool(nThreads):创建固定大小的线程池。
- Executors.newSingleThreadExecutor():创建单个线程的线程池。
查看代码会发现,其实看这三种方式创建的源码就会发现,以上三种都是利用利用 ThreadPoolExecutor
类实现的。
我们学习线程池是如何创建线程的。首先从 ThreadPoolExecutor 构造方法讲起
public ThreadPoolExecutor( int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
这个核心参数的含义:
- corePoolSize 为线程池的基本大小。
- maximumPoolSize 为线程池最大线程大小。
- keepAliveTime 和 unit 则是线程空闲后的存活时间。
- workQueue 用于存放任务的阻塞队列。
- handler 当队列和最大线程池都满了之后的饱和策略(补充一下友好的拒绝策略:①保存到数据库进行削峰填谷,在空闲时再提取出来执行。②转向某个提示页面。③打印日志)。
- TimeUnit 表示时间单位,keepAliveTime的时间单位通常是TimeUnit.SECONDS
通常我们都是使用: threadPool.execute(new Job());
我们先上手写一个简单的线程池:
第一步:建立一个TaskDemo的线程类
import java.util.concurrent.TimeUnit;
public class TaskDemo implements Runnable {
@Override
public void run() {
System.out.println("当前线程名:"+Thread.currentThread().getName()+" is running "+ System.currentTimeMillis());
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
第二步:利用3种常见的线程池的API接口进行线程池的创建
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public class ScheduledDemo {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(5);
// ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 10; i++) {
Runnable task = new TaskDemo();
pool.execute(task);
}
}
}
执行结果为:时间相差5秒,创建固定大小的线程池。
当前线程名:pool-1-thread-2 is running 1612099650398
当前线程名:pool-1-thread-1 is running 1612099650398
当前线程名:pool-1-thread-3 is running 1612099650398
当前线程名:pool-1-thread-4 is running 1612099650398
当前线程名:pool-1-thread-5 is running 1612099650399
当前线程名:pool-1-thread-2 is running 1612099655399
当前线程名:pool-1-thread-1 is running 1612099655399
当前线程名:pool-1-thread-3 is running 1612099655400
当前线程名:pool-1-thread-4 is running 1612099655400
当前线程名:pool-1-thread-5 is running 1612099655400
看到线程池的执行就知道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;
private static final int COUNT_BITS = Integer.SIZE-3;
32位的Integer来表示状态: COUNT_BITS 29位线程数量 高3位是状态码
- RUNNING
(1)状态说明:自然是运行状态,指可以接受任务执行队列里的任务线程池的初始化状态是RUNNING。换句话说,线程池被一旦被创建,就处于RUNNING状态,并且线程池中的任务数为0
(2)状态切换:线程池的初始化状态是RUNNING。换句话说,线程池被一旦被创建,就处于RUNNING状态,并且线程池中的任务数为0!
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
- SHUTDOWN
(1) 状态说明:线程池处在SHUTDOWN状态时,不接收新任务,但能处理已添加的任务。
(2) 状态切换:调用线程池的shutdown()接口时,线程池由RUNNING -> SHUTDOWN。
- STOP
- 状态说明:线程池处在STOP状态时,不接收新任务,不处理已添加的任务,并且会中断正在处理的任务。
- 状态切换:调用线程池的shutdownNow()接口时,线程池由(RUNNING or SHUTDOWN ) -> STOP。
- TIDYING
(1) 状态说明:当所有的任务已终止,任务数量”为0,线程池会变为TIDYING状态。当线程池变为TIDYING状态时,会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的,若用户想在线程池变为TIDYING时,进行相应的处理;可以通过重载terminated()函数来实现。
(2) 状态切换:当线程池在SHUTDOWN状态下,阻塞队列为空并且线程池中执行的任务也为空时,就会由 SHUTDOWN -> TIDYING。 当线程池在STOP状态下,线程池中执行的任务为空时,就会由STOP -> TIDYING。
- TERMINATED 终止状态,当执行 terminated() 后会更新为这个状态。
- 状态说明:线程池彻底终止,就变成TERMINATED状态。
- 状态切换:线程池处在TIDYING状态时,执行完terminated()之后,就会由 TIDYING -> TERMINATED。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();//获取当前线程池的状态
if (workerCountOf(c) < corePoolSize) {//当前线程数量小于 coreSize 时创建一个新的线程运行
if (addWorker(command, true))
return;
c = ctl.get();
}
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);
}
第一次写线程池,感觉有点混乱,最后补充下如何配置核心的几个参数,有一点是肯定的,线程池肯定是不是越大越好
通常我们是需要根据这批任务执行的性质来确定的。
- IO 密集型任务:由于线程并不是一直在运行,所以可以尽可能的多配置线程,比如 CPU 个数 * 2
- CPU 密集型任务(大量复杂的运算)应当分配较少的线程,比如 CPU 个数相当的大小。
当然这些都是经验值,最好的方式还是根据实际情况测试得出最佳配置。
最后请记住:
优雅的关闭线程池!
有运行任务自然也有关闭任务,从上面提到的 5 个状态就能看出如何来关闭线程池。
其实无非就是两个方法 shutdown()/shutdownNow()。
但他们有着重要的区别:
- shutdown() 执行后停止接受新任务,会把队列的任务执行完毕。
- shutdownNow() 也是停止接受新任务,但会中断所有的任务,将线程池状态变为 stop。
最后的最后:线程池不允许使用 Executors ,而是通过 ThreadPoolExecutor 的方式创建 ,这样的处理方式能更加明确线程池的运行规则,规避资源耗尽的风险。
在 ThreadPoolExecutor 中提供了四个公开的内部静态类
• AbortPolicy (默认):丢弃任务并抛出 RejectedExecutionException 异常。
• DiscardPolicy : 丢弃任务,但是不抛出异常 , 这是不推荐的做法。
• DiscardOldestPolicy : 抛弃队列中等待最久的任务 , 然后把当前任务加入队
列中。
• CallerRunsPolicy :调用任务的 run()方法绕过线程池直接执行。
import java.util.concurrent.atomic.AtomicLong;
public class Task implements Runnable {
private final AtomicLong count= new AtomicLong(0L);
@Override
public void run() {
System.out.println("running "+ count.getAndIncrement());
}
}
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
public class UserThreadFactory implements ThreadFactory {
private final String namePrefix;
private final AtomicInteger nextId = new AtomicInteger(1);
UserThreadFactory(String whatFeatureOfGroup) {
namePrefix = "UserThreadFactory's "+whatFeatureOfGroup+" -Worker-";}
@Override
public Thread newThread(Runnable task){
String name = namePrefix + nextId.getAndIncrement();
Thread thread= new Thread(null,task,name,0);
System.out.println(thread.getName());
return thread;
}
}
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class UserRejectHandler implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("task rejected "+ executor.toString());
}
}
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class UserThreadPool {
public static void main(String[] args ) {
BlockingQueue queue = new LinkedBlockingQueue( 2 );
UserThreadFactory fl = new UserThreadFactory ("第一号机房");
UserThreadFactory f2 = new UserThreadFactory ("第一号机房");
UserRejectHandler handler = new UserRejectHandler();
ThreadPoolExecutor threadPoolFirst
= new ThreadPoolExecutor(1,2,60 ,
TimeUnit.SECONDS , queue , fl , handler);
ThreadPoolExecutor threadPoolSecond
= new ThreadPoolExecutor(1,2 , 60 ,
TimeUnit . SECONDS , queue , f2 , handler) ;
Runnable task= new Task();
for (int i = 0; i < 200 ; i++) {
threadPoolFirst.execute(task);
threadPoolSecond.execute(task);
}
}
}
UserThreadFactory's 第一号机房 -Worker-1
UserThreadFactory's 第一号机房 -Worker-1
UserThreadFactory's 第一号机房 -Worker-2
UserThreadFactory's 第一号机房 -Worker-2
running 0
running 1
running 2
running 3
running 4
running 5
task rejected java.util.concurrent.ThreadPoolExecutor@135fbaa4[Running, pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 3]
task rejected java.util.concurrent.ThreadPoolExecutor@45ee12a7[Running, pool size = 2, active threads = 0, queued tasks = 2, completed tasks = 3]
当任务被拒绝的时候,拒绝策略会打印出当前线程池的大小已经达到了
maximumPoolSize=2 ,且队列已满,完成的任务数提示已经有 1 个(最后一行)。
PS:以上部分引用自《码出高效-Java开发手册》,非商业用途,仅供学习。