线程池技术
- 为什么需要使用线程池
- Java中提供的线程池
- 线程池原理(ThreadPoolExecutor)
- 线程池的设计
- 源码分析
- execute
- addWorker
- worker.run()
- getTask
- 线程池参数设置
为什么需要使用线程池
在使用线程的时候需要频繁的创建和销毁线程。
线程的数量过多，会造成CPU资源的开销。如线程数量超过CPU核数就会造成频繁的上下文切换，是十分消耗CPU资源的。
为了实现线程的复用，我们使用线程池提前拿创建一系列的线程，保存在这个线程池中，有任务执行的时候，从线程池中取出线程来执行，没有任务的时候，将线程放回到线程池中。
Java中提供的线程池
Executors
- newFixedThreadPool 固定线程的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}- newSingleThreadExecutor 只有一个线程的线程池
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}- newCachedThreadPool 可以缓存的线程池 =>有多少请求，就可以创建多少的线程来处理
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}- newScheduledThreadPool 提供了按周期执行的线程池 => Timer
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}线程池原理(ThreadPoolExecutor)
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;
}线程池的设计
需求：实现线程的重复使用
- 如何实现线程的复用？
让线程复用的方法就是让线程不结束。 - 线程不结束的情况下如何给线程执行新的任务？
给它一个共享内存，如一个List，不断地add任务。 - 线程一直处于运行状态，怎么办？
有任务的时候执行。没有任务的时候阻塞。
结论：通过阻塞队列从List里面取出task进行执行。
源码分析
- 线程池中的核心线程是延迟初始化的。
- 先初始化核心线程。
- 调用阻塞队列的方法，把task存进去。(offer() => true/false)
- 如果为true，说明当前请求量不大，核心线程就可以搞定。
- 如果为false，增加工作线程(非核心线程)
- 如果添加失败，说明当前的工作线程数量达到了最大的线程数，直接调用拒绝策略。
execute
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 判断当前的工作线程数是否小于核心线程数
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true)) // 添加工作线程的同时，执行command
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); // 执行拒绝策略
}这里涉及到一个延迟初始化，类似于单例中的懒加载，只有在使用的时候才去创建或者加载它，这种思想在我们平时的业务逻辑中也可以考虑使用，很多时候需要计算一些值不一定需要定时任务去计算，如果一些业务使用量较少可以采取业务驱动、延时处理的方式，在需要查看的时候进行计算即可。
addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
//case1： 通过原子操作来增加线程数量
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
}
}
//case2：初始化工作线程
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
largestPoolSize = s;
workerAdded = true; //添加成功
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start(); //启动线程
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}worker.run()
public void run() {
runWorker(this);
}final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//while循环保证当前线程不结束，直到task为null
while (task != null || (task = getTask()) != null) {
//表示当前线程正在运行一个任务，如果其他地方要shutdown()，必须要等待执行完成。
w.lock(); //Worker继承了AQS => 实现了互斥锁
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt(); //是否触发中断
try {
beforeExecute(wt, task); //空的实现，留给他人扩展
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}getTask
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) { //cas 自旋
int c = ctl.get();
int rs = runStateOf(c);
//如果线程池已经结束状态，直接返回null，需要清理掉所有的工作线程
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
//是否允许超时
//1. allowCoreThreadTimeOut为true
//2. 如果当前的工作线程数量大于核心线程数
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c)) //cas 减少工作线程数量
return null; //销毁当前工作线程
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take(); //如果阻塞队列没有任务，当前工作线程会阻塞在这里
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}线程池参数设置
- IO密集型
CPU利用率不高 理论上设置 2*CPU core+1
- CPU密集型
CPU利用率很高，会增加上下文切换 理论上设置 CPU core+1
我们在实际场景中还可以通过动态设置的方式设置线程池参数。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
