本文深入探讨Java线程池的工作原理，包括线程池的概念、实现原理、创建方式及任务提交方法。通过示例代码展示execute与submit的区别，以及如何合理配置线程池参数。
前言：
上一部分，我们简单的学习了java的并发工具类，这部分我们开始学习java的线程池
1. 什么是线程池
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。这避免了在处理短时间任务时创建与销毁线程的代价。java中的线程池是运用场景最多的并发框架，几乎所有需要异步或者并发执行任务的程序都可以使用线程池，在开发过程中，合理使用线程池可以带来3个好处。
1.降低资源消耗 重复利用已创建的线程降低线程创建和销毁带来的消耗
2.提高响应速度 任务到达时，可以不用等创建线程就立即执行
3.提高线程的可管理性 使用线程池可以统一分配、调优和监控线程
2. 线程池的实现原理
当向线程池提交一个任务后，线程池是如何处理这个任务的呢，接下来我们看一下线程池的处理流程
从图可知，一个新任务提交到线程池时，线程池会这样处理
- 判断核心线程池是否都在执行任务，如果不是，创建一个新的工作线程来执行任务，如果核心线程池里的线程都在执行任务，则进入下一个流程
- 线程池判断工作队列是否已满，如果工作队列没有满，则新提交的任务存储在这个工作队列里，如果工作队列满了，则进入下一个流程
- 线程池判断线程池的线程是否都处在工作状态，如果没有，则创建一个新的工作线程来执行任务，如果已经满了，则交给饱和策略来处理这个任务
ThreadPoolExecutor执行execute方法的示意图如下
ThreadPoolExecutor执行execute()方法分四种情况
- 如果当前运行线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步需要获取全局锁）
- 如果运行的线程等于或少于corePoolSize，则将任务加入BlockingQueue
- 如果无法将任务加入BlockingQueue（队列满），则创建新的线程来处理任务（执行这一步需要获取全局锁）
- 如果创建新线程使当前运行线程超出maximunPoolSize，任务会被拒绝，调用RejectedExecutionHandler.rejectedExecution方法
下面我们来看一下excute的实现源码
/**
* Executes the given task sometime in the future. The task
* may execute in a new thread or in an existing pooled thread.
*
* If the task cannot be submitted for execution, either because this
* executor has been shutdown or because its capacity has been reached,
* the task is handled by the current {@code RejectedExecutionHandler}.
*
* @param command the task to execute
* @throws RejectedExecutionException at discretion of
* {@code RejectedExecutionHandler}, if the task
* cannot be accepted for execution
* @throws NullPointerException if {@code command} is null
*/
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();
// 如果当前线程数少于核心线程数，直接添加一个 worker 执行任务，
// 创建一个新的线程，并把当前任务 command 作为这个线程的第一个任务(firstTask)
if (workerCountOf(c) < corePoolSize) {
// 添加任务成功，即结束
// 执行的结果，会包装到 FutureTask
// 返回 false 代表线程池不允许提交任务
if (addWorker(command, true))
return;
c = ctl.get();
}
// 到这说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败
// 如果线程池处于 RUNNING ，把这个任务添加到任务队列 workQueue 中
if (isRunning(c) && workQueue.offer(command)) {
/* 若任务进入 workQueue，我们是否需要开启新的线程
* 线程数在 [0, corePoolSize) 是无条件开启新线程的
* 若线程数已经大于等于 corePoolSize，则将任务添加到队列中，然后进到这里
*/
int recheck = ctl.get();
// 若线程池不处于 RUNNING ，则移除已经入队的这个任务，并且执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 若线程池还是 RUNNING ，且线程数为 0，则开启新的线程
// 这块代码的真正意图：担心任务提交到队列中了，但是线程都关闭了
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 若 workQueue 满，到该分支
// 以 maximumPoolSize 为界创建新 worker，
// 若失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
工作线程：线程池创建线程时，会将线程封装成工作线程worker，worker在执行完任务后，还会循环获取工作队列里的任务来执行，我们来看一下worker类的run方法的具体实现方法runWorker
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 || (task = getTask()) != null) {
w.lock();
// 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);
}
}
ThreadPoolExecutor中线程执行任务的示意图如下
线程池中的线程执行任务分两种情况，一是execute()方法创建出一个线程时，让这个线程去执行任务，二是执行完1的任务后反复从BlockingQueue中获取任务执行。
3. 线程池的创建
我们可以通过ThreadPoolExecutor来创建一个线程池
new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAlive,miliseconds,runnableTaskQueue,handler);
创建线程池需要的参数解释如下
1.corePoolSize
表示线程池的常驻核心线程数。如果设置为0，则表示在没有任何任务时，销毁线程池；如果大于0，即使没有任务时也会保证线程池的线程数量等于此值。但需要注意，此值如果设置的比较小，则会频繁的创建和销毁线程，如果设置的比较大，则会浪费系统资源
2. maximumPoolSize
表示线程池在任务最多时，最大可以创建的线程数。官方规定此值必须大于 0，也必须大于等于 corePoolSize，此值只有在任务比较多，且不能存放在任务队列时，才会用到。
3. keepAliveTime
表示线程的存活时间，当线程池空闲时并且超过了此时间，多余的线程就会销毁，直到线程池中的线程数量销毁的等于corePoolSize为止。
4.ThreadFactory
表示线程的创建工厂，此参数一般用的比较少，我们通常在创建线程池时不指定此参数，它会使用默认的线程创建工厂的方法来创建线程
//Executors.defaultThreadFactory() 默认的线程创建工厂
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
5. runnableTaskQueue（任务队列）
- ArrayBlockingQueue 是一个基于数组的有界阻塞队列，此队列按FIFO原则对元素排序
- LinkedBlockingQueue 一个基于链表的阻塞队列，此队列按FIFO原则对元素排序，静态工厂方法Executors.newFixedThreadPool方法使用了这个队列
- SynchronousQueue 一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，静态工厂方法Executors.newCachedThreadPool方法使用了这个队列
- PriorityBlockingQueue 一个具有优先级的无界阻塞队列
6. RejectedExecutionHandler（拒绝策略）
线程池的任务已经在缓存队列 workQueue 中存储满了之后，并且不能创建新的线程来执行此任务时，就会用到此拒绝策略，它属于一种限流保护的机制。java一共提供了四种拒绝策略
- AbortPolicy 直接抛出异常
- CallerRunsPolicy 只用调用者所在的线程来运行任务
- DiscardOldestPolicy 丢弃队列里最近的一个任务，并执行当前任务
- DiscardPolicy 不处理，丢弃掉
4. 向线程池提交任务
可以用两个方法向线程池提交任务，分别为execute方法和submit方法，execute用于提交不需要返回值的任务，submit用于提交需要返回值的任务，线程池会返回一个Future对象，通过Future对象可以判断任务是否执行成功，并且可以通过future的get方法来获取返回值，get方法会阻塞当前线程直到任务完成
首先我们看一下execute的使用演示
public class ThreadPoolExcutorTest {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
for (int i = 0; i < 5; i++) {
int finalI = i;
service.execute(() -> {
System.out.println("当前线程" + Thread.currentThread().getName() + " 执行第" + finalI + "次");
});
}
service.shutdown();
}
}
//结果
当前线程pool-1-thread-1 执行第0次
当前线程pool-1-thread-1 执行第1次
当前线程pool-1-thread-1 执行第2次
当前线程pool-1-thread-1 执行第3次
当前线程pool-1-thread-1 执行第4次
再看下submit的使用演示
public class ThreadPoolExcutorTest {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
Future<String> future = service.submit(new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("submit方法执行完成，线程为：" + Thread.currentThread().getName());
return "success";
}
});
service.shutdown();
try {
String s = future.get();
if("success".equals(s)){
System.out.println("经过返回值比较，执行成功");
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//结果
submit方法执行完成，线程为：pool-1-thread-1
经过返回值比较，执行成功
最后有一点，用完了线程池不要忘记调用threadPool.shutDown方法关闭线程池，它的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法中断线程，所以无法响应中断的线程可能永远无法结束。
总结
本部分我们一起学些了java的线程池的内容，下一部分我们将学习Executor框架的内容
扫一扫
1063
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
