この列には、大きなシェア知識バットのインタビューを焦点を当てて、フォローアップは、トラブルの懸念をクリックするように、更新していきます
1.はじめに
スレッドプールは、単純に作成し、頻繁にもたらしたスレッドを破壊するオーバーヘッドを回避するために、我々は簡単にスレッドを再利用することができ、スレッドプールを使用することにより、スレッドのコレクションとして見ることができます。アプリケーションでは、スレッドプールは、バックエンドに関連するサービスに使用することができます。そのようなので、上のWebサーバー、データベースサーバー、およびなど。Webサーバ、例えば、この時点で我々は単に各HTTP要求の処理スレッドを作成する場合、Webサーバーは、短期HTTPリクエストが多数を受信した場合、サーバーのリソースがすぐに使い果たされます。もちろん、我々はまた、スレッドがリソースの消費を制限するために作成された管理し、再利用するために所有することができますが、それはプログラムのロジックが複雑になる使用されます。幸いにも、幸いにも、我々はそれを行う必要はありません。JDK 1.5では、公式には、強力なツールのスレッドプールのクラスを提供してきました。これらのツールを使用することにより、我々は、低価格でマルチスレッド技術を使用することができます。
並行クラスのための重要なツールとしてJavaスレッド・プールに基づいて使用され、私はスレッドプールの関連する原則を学ぶことが必要だと思います。すべての後に、スレッドプールのスレッド管理に加えて、だけでなく、管理タスク、だけでなく、統計的な機能を持っています。だから、少し理解するために、それはまだ彼らの視野を広げることができ、また、スレッド・プールに慣れすることができます。
2.継承システム
関連するスレッド・プールには、システムを継承するインタフェースとクラスの多くは比較的単純ではありません。次のように相続に関連しています。
上記のように、トップレベルインターフェースキュータ単一の方法execute。声明を含むがこれらに限定されないインターフェイスに基づいてExecutorServiceの親クラス・インターフェース、shutdown、submit、invokeAll、invokeAny など。ScheduledExecutorServiceインターフェースとして、それのような、タイミングおよび方法に関連するタスクの数を宣言することである scheduleとscheduleAtFixedRate。コアスレッドプールはThreadPoolExecutorクラスで達成され、我々は、エグゼキュータ・コールを使用newFixedThreadPool、newSingleThreadExecutorおよびnewCachedThreadPoolスレッドプールを作成するために、他の方法をThreadPoolExecutorタイプです。
上記の継承されたシステムスレッドプールの簡単な紹介で、ここでは誰もがスレッドプールの幅広い輪郭をある程度理解してみましょう。次に、私が読みしていき、スレッドプールの実装の原則を紹介します。
3.原則の分析
コアパラメータの3.1分析
炉心パラメータに3.1.1の紹介
上記セクション、ThreadPoolExecutorクラスであるコアスレッドプールの実装。コアクラスは、いくつかの属性は、コンストラクタで初期化することができます含まれています。次のようにコア属性を導入する前に、我々は、ThreadPoolExecutorコンストラクタを見てみましょう：
公共ThreadPoolExecutor（int型corePoolSize、
int型maximumPoolSize、
長いkeepAliveTimeが、
TimeUnitでユニット、
BlockingQueueの<Runnableを>ワークキュー、
ThreadFactory threadFactory、
のRejectedExecutionHandlerハンドラ）
上記のように、それはコアの引数のコンストラクタのパラメータは、ここで私は簡単に各パラメータの重要性を説明するために、テーブルを使用しています。次のように：
| パラメータ | 説明 |
|---|---|
| corePoolSize | スレッドのコア数。値は、スレッドの数より少ない場合、スレッド・プールには、新しいタスクを実行する新しいスレッドを作成するために優先させて頂きます |
| maximumPoolSize | スレッドプール内のスレッドの最大数を維持することができます |
| keepAliveTimeが | アイドルスレッドの生存期間 |
| ワークキュー | キャッシュによって実行されるタスクのためのタスクキュー |
| threadFactory | スレッドファクトリ。これは、新しいスレッドのために工場より意味のある名前で設定することができます |
| ハンドラ | 拒否ポリシー。タスクキューとスレッドプールが飽和点にあるときは、新しいタスクを処理するための戦略を使用することを拒否しました。デフォルトではAbortPolicy、すなわち直接スロー例外で |
これらは、各パラメータの簡単な紹介です、私は読み、いくつかのパラメータについて以下に詳細に説明します。
3.1.2スレッドの作成ルール
在 Java 线程池实现中，线程池所能创建的线程数量受限于 corePoolSize 和 maximumPoolSize 两个参数值。线程的创建时机则和 corePoolSize 以及 workQueue 两个参数有关。下面列举一下线程创建的4个规则（线程池中无空闲线程），如下：
-
线程数量小于 corePoolSize，直接创建新线程处理新的任务
-
线程数量大于等于 corePoolSize，workQueue 未满，则缓存新任务
-
线程数量大于等于 corePoolSize，但小于 maximumPoolSize，且 workQueue 已满。则创建新线程处理新任务
-
线程数量大于等于 maximumPoolSize，且 workQueue 已满，则使用拒绝策略处理新任务
简化一下上面的规则：
| 序号 | 条件 | 动作 |
|---|---|---|
| 1 | 线程数 < corePoolSize | 创建新线程 |
| 2 | 线程数 ≥ corePoolSize，且 workQueue 未满 | 缓存新任务 |
| 3 | corePoolSize ≤ 线程数 ＜ maximumPoolSize，且 workQueue 已满 | 创建新线程 |
| 4 | 线程数 ≥ maximumPoolSize，且 workQueue 已满 | 使用拒绝策略处理 |
3.1.3 资源回收
考虑到系统资源是有限的，对于线程池超出 corePoolSize 数量的空闲线程应进行回收操作。进行此操作存在一个问题，即回收时机。目前的实现方式是当线程空闲时间超过 keepAliveTime 后，进行回收。除了核心线程数之外的线程可以进行回收，核心线程内的空闲线程也可以进行回收。回收的前提是allowCoreThreadTimeOut属性被设置为 true，通过public void allowCoreThreadTimeOut(boolean) 方法可以设置属性值。
3.1.4 排队策略
如3.1.2 线程创建规则一节中规则2所说，当线程数量大于等于 corePoolSize，workQueue 未满时，则缓存新任务。这里要考虑使用什么类型的容器缓存新任务，通过 JDK 文档介绍，我们可知道有3中类型的容器可供使用，分别是同步队列，有界队列和无界队列。对于有优先级的任务，这里还可以增加优先级队列。以上所介绍的4中类型的队列，对应的实现类如下：
| 实现类 | 类型 | 说明 |
|---|---|---|
| SynchronousQueue | 同步队列 | 该队列不存储元素，每个插入操作必须等待另一个线程调用移除操作，否则插入操作会一直阻塞 |
| ArrayBlockingQueue | 有界队列 | 基于数组的阻塞队列，按照 FIFO 原则对元素进行排序 |
| LinkedBlockingQueue | 无界队列 | 基于链表的阻塞队列，按照 FIFO 原则对元素进行排序 |
| PriorityBlockingQueue | 优先级队列 | 具有优先级的阻塞队列 |
3.1.5 拒绝策略
如3.1.2 线程创建规则一节中规则4所说，线程数量大于等于 maximumPoolSize，且 workQueue 已满，则使用拒绝策略处理新任务。Java 线程池提供了4中拒绝策略实现类，如下：
| 实现类 | 说明 |
|---|---|
| AbortPolicy | 丢弃新任务，并抛出 RejectedExecutionException |
| DiscardPolicy | 不做任何操作，直接丢弃新任务 |
| DiscardOldestPolicy | 丢弃队列队首的元素，并执行新任务 |
| CallerRunsPolicy | 由调用线程执行新任务 |
以上4个拒绝策略中，AbortPolicy 是线程池实现类所使用的策略。我们也可以通过方法public void setRejectedExecutionHandler(RejectedExecutionHandler)修改线程池决绝策略。
3.2 重要操作
3.2.1 线程的创建与复用
在线程池的实现上，线程的创建是通过线程工厂接口ThreadFactory的实现类来完成的。默认情况下，线程池使用Executors.defaultThreadFactory()方法返回的线程工厂实现类。当然，我们也可以通过
public void setThreadFactory(ThreadFactory)方法进行动态修改。具体细节这里就不多说了，并不复杂，大家可以自己去看下源码。
在线程池中，线程的复用是线程池的关键所在。这就要求线程在执行完一个任务后，不能立即退出。对应到具体实现上，工作线程在执行完一个任务后，会再次到任务队列获取新的任务。如果任务队列中没有任务，且 keepAliveTime 也未被设置，工作线程则会被一致阻塞下去。通过这种方式即可实现线程复用。
说完原理，再来看看线程的创建和复用的相关代码（基于 JDK 1.8），如下：
+----ThreadPoolExecutor.Worker.java
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
// 调用线程工厂创建线程
this.thread = getThreadFactory().newThread(this);
}
// Worker 实现了 Runnable 接口
public void run() {
runWorker(this);
}
+----ThreadPoolExecutor.java
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock();
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);
}
}
3.2.2 提交任务
通常情况下，我们可以通过线程池的submit方法提交任务。被提交的任务可能会立即执行，也可能会被缓存或者被拒绝。任务的处理流程如下图所示：
上面的流程图不是很复杂，下面再来看看流程图对应的代码，如下：
+---- AbstractExecutorService.java
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
// 创建任务
RunnableFuture<Void> ftask = newTaskFor(task, null);
// 提交任务
execute(ftask);
return ftask;
}
+---- ThreadPoolExecutor.java
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 如果工作线程数量 < 核心线程数，则创建新线程
if (workerCountOf(c) < corePoolSize) {
// 添加工作者对象
if (addWorker(command, true))
return;
c = ctl.get();
}
// 缓存任务，如果队列已满，则 offer 方法返回 false。否则，offer 返回 true
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);
}
// 添加工作者对象，并在 addWorker 方法中检测线程数是否小于最大线程数
else if (!addWorker(command, false))
// 线程数 >= 最大线程数，使用拒绝策略处理任务
reject(command);
}
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 (;;) {
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
}
}
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 {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 将 worker 对象添加到 workers 集合中
workers.add(w);
int s = workers.size();
// 更新 largestPoolSize 属性
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 开始执行任务
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
上面的代码略多，不过结合上面的流程图，和我所写的注释，理解主逻辑应该不难。
3.2.3 关闭线程池
我们可以通过shutdown和shutdownNow两个方法关闭线程池。两个方法的区别在于，shutdown 会将线程池的状态设置为SHUTDOWN，同时该方法还会中断空闲线程。shutdownNow 则会将线程池状态设置为STOP，并尝试中断所有的线程。中断线程使用的是Thread.interrupt方法，未响应中断方法的任务是无法被中断的。最后，shutdownNow 方法会将未执行的任务全部返回。
调用 shutdown 和 shutdownNow 方法关闭线程池后，就不能再向线程池提交新任务了。对于处于关闭状态的线程池，会使用拒绝策略处理新提交的任务。
4.几种线程池
一般情况下，我们并不直接使用 ThreadPoolExecutor 类创建线程池，而是通过 Executors 工具类去构建线程池。通过 Executors 工具类，我们可以构造5中不同的线程池。下面通过一个表格简单介绍一下几种线程池，如下：
| 静态构造方法 | 说明 |
|---|---|
| newFixedThreadPool(int nThreads) | 构建包含固定线程数的线程池，默认情况下，空闲线程不会被回收 |
| newCachedThreadPool() | 构建线程数不定的线程池，线程数量随任务量变动，空闲线程存活时间超过60秒后会被回收 |
| newSingleThreadExecutor() | 构建线程数为1的线程池，等价于 newFixedThreadPool(1) 所构造出的线程池 |
| newScheduledThreadPool(int corePoolSize) | 构建核心线程数为 corePoolSize，可执行定时任务的线程池 |
| newSingleThreadScheduledExecutor() | 等价于 newScheduledThreadPool(1) |
关于我
更多信息可以点击关于我 , 非常希望和大家一起交流 , 共同进步