Javaスレッドプールの詳しい説明とサンプルコード-＆＃＆チュートリアル-php.cn

スレッドプールの技術的背景

オブジェクト指向プログラミングでは、オブジェクトの作成にはメモリリソースなどのリソースを取得する必要があるため、オブジェクトの作成と破棄には非常に時間がかかります。これは特に Java に当てはまります。Java では、オブジェクトが破棄された後にガベージコレクションできるように、仮想マシンはすべてのオブジェクトを追跡しようとします。

したがって、サービスプログラムの効率を向上させる 1 つの方法は、オブジェクトの作成と破棄の数、特にリソースを消費する一部のオブジェクトの作成と破棄の数をできる限り減らすことです。既存のオブジェクトをどのように使用してサービスを提供するかは、解決する必要がある重要な問題です。実際、これがいくつかの「プールされたリソース」テクノロジーの出現の理由です。

たとえば、Android で一般的に見られる多くの一般的なコンポーネントは、一般に、さまざまな画像読み込みライブラリ、ネットワークリクエストライブラリ、さらには Android のメッセージングメカニズムの Meaasge など、Meaasge.obtain() を使用する場合に「プール」の概念から切り離すことができません。したがって、この概念は重要です。この記事で紹介したスレッドプールテクノロジも、この考え方と一致しています。

スレッドプールの利点:

1. スレッドプール内のスレッドを再利用し、オブジェクトの作成と破棄によって生じるパフォーマンスのオーバーヘッドを削減します。

2. 過剰なスレッドを回避しながら、同時スレッドの最大数を効果的に制御できます。リソースの競合と輻輳

3. マルチスレッドの簡単な管理を実行できるため、スレッドの使用が簡単かつ効率的になります。

スレッドプールフレームワーク Executor

Java のスレッドプールは、Executor フレームワークを通じて実装されます。Executor フレームワークには、Executor、Executors、ExecutorService、ThreadPoolExecutor、Callable、Future、FutureTask の使用などのクラスが含まれます。

Java 线程池详解及实例代码

Executor: すべてのスレッドプールインターフェイスにはメソッドが 1 つだけあります。

public interface Executor { 
 void execute(Runnable command); 
}

ログイン後にコピー

ExecutorService: Executor の動作を追加し、Executor 実装クラスの最も直接的なインターフェイスです。

Executors: スレッドプールを作成するための一連のファクトリメソッドを提供し、返されるスレッドプールはすべて ExecutorService インターフェイスを実装します。

ThreadPoolExecutor: スレッドプールの特定の実装クラス。一般的に使用されるさまざまなスレッドプールは、このクラスに基づいて実装されます。構築方法は次のとおりです。

public ThreadPoolExecutor(int corePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
 
Executors.defaultThreadFactory(), defaultHandler);
 
}

ログイン後にコピー

corePoolSize: スレッドプール内のコアスレッドの数は、デフォルトでは corePoolSize を超えることはありません。このとき、allowCoreThreadTimeOut を True に設定できます。このとき、コアスレッドの数は 0 です。このとき、keepAliveTime はすべてのスレッドのタイムアウトを制御します。

maximumPoolSize: スレッドプールで許可される最大スレッド数;

keepAliveTime: アイドル状態のスレッドが終了するときのタイムアウト期間を指します。

unit: keepAliveTime の単位を表す列挙です。実行可能なキューを保存します。

BlockingQueue: BlockingQueue は java.util.concurrent の下にあるツールで、主にスレッドの同期を制御するために使用されます。 BlockQueue が空の場合、BlockingQueue から何かを取得する操作はブロックされて待機状態になり、何かが BlockingQueue に入るまで起動されません。同様に、BlockingQueue がいっぱいの場合、そこに何かを保存しようとする操作もブロックされ、BlockingQueue に空きができるまで操作を続行するために起動されません。ブロッキングキューは、プロデューサーおよびコンシューマーのシナリオでよく使用されます。プロデューサーはキューに要素を追加するスレッドであり、コンシューマーはキューから要素を取得するスレッドです。ブロッキングキューは、プロデューサーが要素を格納するコンテナーであり、コンシューマーはコンテナーから要素のみを取得します。特定の実装クラスには、LinkedBlockingQueue、ArrayBlockingQueued などが含まれます。一般に、ブロックと覚醒は、Lock と Condition (表示ロック (Lock) と条件の学習と使用) を通じて内部的に実装されます。

スレッドプールの動作プロセスは次のとおりです:

スレッドプールが最初に作成されたとき、その中にスレッドはありません。タスクキューはパラメータとして渡されます。ただし、キューにタスクがあっても、スレッドプールはそれらのタスクをすぐには実行しません。

タスクを追加するためにexecute()メソッドが呼び出されるとき、スレッドプールは次の判断を行います:

実行中のスレッドの数がcorePoolSizeより少ない場合は、タスクを実行するためのスレッドをすぐに作成します。実行中のスレッドの数が corePoolSize 以上である場合は、タスクをキューに入れます

この時点でキューがいっぱいで、実行中のスレッドの数が maxPoolSize 未満の場合でも、非コアスレッドでタスクをすぐに実行します。

キューがいっぱいで実行中の場合、スレッドの数が maxPoolSize 以上である場合、スレッドプールは例外 RejectExecutionException をスローします。

スレッドがタスクを完了すると、キューからタスクを取得して実行します。

スレッドが何もせずに一定時間 (keepAliveTime) を超えると、現在実行中のスレッドの数が corePoolSize よりも大きい場合、スレッドプールはスレッドを停止すると判断します。したがって、スレッドプールのすべてのタスクが完了すると、最終的には corePoolSize のサイズまで縮小します。

スレッドプールの作成と使用

スレッドプールは、ツールクラス Executor の静的メソッドを使用して生成されます。次に、いくつかの一般的なスレッドプールを示します。

SingleThreadExecutor: 単一のバックグラウンドスレッド (バッファキューは無制限です)

public static ExecutorService newSingleThreadExecutor() { 
 return new FinalizableDelegatedExecutorService (
  new ThreadPoolExecutor(1, 1,        
  0L, TimeUnit.MILLISECONDS,        
  new LinkedBlockingQueue<Runnable>()));
}

ログイン後にコピー

创建一个单线程的线程池。这个线程池只有一个核心线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

FixedThreadPool：只有核心线程的线程池,大小固定 (其缓冲队列是无界的) 。

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

CachedThreadPool：无界线程池，可以进行自动线程回收。

public static ExecutorService newCachedThreadPool() {  
 return new ThreadPoolExecutor(0,Integer.MAX_VALUE,          
   60L, TimeUnit.SECONDS,         
   new SynchronousQueue<Runnable>()); 
}

ログイン後にコピー

如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。SynchronousQueue是一个是缓冲区为1的阻塞队列。

ScheduledThreadPool：核心线程池固定，大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

public static ExecutorService newScheduledThreadPool(int corePoolSize) {  
 return new ScheduledThreadPool(corePoolSize,
    Integer.MAX_VALUE,            
    DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,            
    new DelayedWorkQueue());
}

ログイン後にコピー

创建一个周期性执行任务的线程池。如果闲置,非核心线程池会在DEFAULT_KEEPALIVEMILLIS时间内回收。

线程池最常用的提交任务的方法有两种：

execute:

ExecutorService.execute(Runnable runable)；

submit:

FutureTask task = ExecutorService.submit(Runnable runnable);
FutureTask task = ExecutorService.submit(Runnable runnable,T Result);

FutureTask task = ExecutorService.submit(Callable callable);

submit(Callable callable)的实现，submit(Runnable runnable)同理。

public <T> Future<T> submit(Callable<T> task) {
 if (task == null) throw new NullPointerException();
 FutureTask<T> ftask = newTaskFor(task);
 execute(ftask);
 return ftask;
}

ログイン後にコピー

可以看出submit开启的是有返回结果的任务，会返回一个FutureTask对象，这样就能通过get()方法得到结果。submit最终调用的也是execute(Runnable runable)，submit只是将Callable对象或Runnable封装成一个FutureTask对象，因为FutureTask是个Runnable，所以可以在execute中执行。关于Callable对象和Runnable怎么封装成FutureTask对象，见Callable和Future、FutureTask的使用。

线程池实现的原理

如果只讲线程池的使用，那这篇博客没有什么大的价值，充其量也就是熟悉Executor相关API的过程。线程池的实现过程没有用到Synchronized关键字，用的都是Volatile,Lock和同步(阻塞)队列,Atomic相关类，FutureTask等等，因为后者的性能更优。理解的过程可以很好的学习源码中并发控制的思想。

在开篇提到过线程池的优点是可总结为以下三点：

线程复用

控制最大并发数

管理线程

1.线程复用过程

理解线程复用原理首先应了解线程生命周期。

Java 线程池详解及实例代码

在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态。

Thread通过new来新建一个线程，这个过程是是初始化一些线程信息，如线程名，id,线程所属group等，可以认为只是个普通的对象。调用Thread的start()后Java虚拟机会为其创建方法调用栈和程序计数器，同时将hasBeenStarted为true,之后调用start方法就会有异常。

处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。当线程获取cpu后，run()方法会被调用。不要自己去调用Thread的run()方法。之后根据CPU的调度在就绪——运行——阻塞间切换，直到run()方法结束或其他方式停止线程，进入dead状态。

所以实现线程复用的原理应该就是要保持线程处于存活状态（就绪，运行或阻塞）。接下来来看下ThreadPoolExecutor是怎么实现线程复用的。

在ThreadPoolExecutor主要Worker类来控制线程的复用。看下Worker类简化后的代码，这样方便理解：

private final class Worker implements Runnable {
final Thread thread;
 
Runnable firstTask;
 
Worker(Runnable firstTask) {
 
this.firstTask = firstTask;
 
this.thread = getThreadFactory().newThread(this);
 
}
 
public void run() {
 
runWorker(this);
 
}
 
final void runWorker(Worker w) {
 
Runnable task = w.firstTask;
 
w.firstTask = null;
 
while (task != null || (task = getTask()) != null){
 
task.run();
 
}
 
}

ログイン後にコピー

Worker是一个Runnable，同时拥有一个thread，这个thread就是要开启的线程，在新建Worker对象时同时新建一个Thread对象，同时将Worker自己作为参数传入TThread，这样当Thread的start()方法调用时，运行的实际上是Worker的run()方法，接着到runWorker()中,有个while循环，一直从getTask()里得到Runnable对象，顺序执行。getTask()又是怎么得到Runnable对象的呢？

依旧是简化后的代码：

private Runnable getTask() {
 if(一些特殊情况) {
  return null;
 }
Runnable r = workQueue.take();
 
return r;
 
}

ログイン後にコピー

这个workQueue就是初始化ThreadPoolExecutor时存放任务的BlockingQueue队列，这个队列里的存放的都是将要执行的Runnable任务。因为BlockingQueue是个阻塞队列，BlockingQueue.take()得到如果是空，则进入等待状态直到BlockingQueue有新的对象被加入时唤醒阻塞的线程。所以一般情况Thread的run()方法就不会结束,而是不断执行从workQueue里的Runnable任务，这就达到了线程复用的原理了。

2.控制最大并发数

那Runnable是什么时候放入workQueue？Worker又是什么时候创建，Worker里的Thread的又是什么时候调用start()开启新线程来执行Worker的run()方法的呢？有上面的分析看出Worker里的runWorker()执行任务时是一个接一个，串行进行的，那并发是怎么体现的呢？

很容易想到是在execute(Runnable runnable)时会做上面的一些任务。看下execute里是怎么做的。

execute:

简化后的代码

public void execute(Runnable command) {
 if (command == null)
  throw new NullPointerException();
int c = ctl.get();
 
// 当前线程数 < corePoolSize
 
if (workerCountOf(c) < corePoolSize) {
 
// 直接启动新的线程。
 
if (addWorker(command, true))
 
return;
 
c = ctl.get();
 
}
 
// 活动线程数 >= corePoolSize
 
// runState为RUNNING && 队列未满
 
if (isRunning(c) && workQueue.offer(command)) {
 
int recheck = ctl.get();
 
// 再次检验是否为RUNNING状态
 
// 非RUNNING状态 则从workQueue中移除任务并拒绝
 
if (!isRunning(recheck) && remove(command))
 
reject(command);// 采用线程池指定的策略拒绝任务
 
// 两种情况：
 
// 1.非RUNNING状态拒绝新的任务
 
// 2.队列满了启动新的线程失败（workCount > maximumPoolSize）
 
} else if (!addWorker(command, false))
 
reject(command);
 
}

ログイン後にコピー

addWorker:

简化后的代码

private boolean addWorker(Runnable firstTask, boolean core) {
int wc = workerCountOf(c);
 
if (wc >= (core ? corePoolSize : maximumPoolSize)) {
 
return false;
 
}
 
w = new Worker(firstTask);
 
final Thread t = w.thread;
 
t.start();
 
}

ログイン後にコピー

根据代码再来看上面提到的线程池工作过程中的添加任务的情况：

* 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
* 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
* 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
* 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常RejectExecutionException。

这就是Android的AsyncTask在并行执行是在超出最大任务数是抛出RejectExecutionException的原因所在，详见基于最新版本的AsyncTask源码解读及AsyncTask的黑暗面

通过addWorker如果成功创建新的线程成功，则通过start()开启新线程，同时将firstTask作为这个Worker里的run()中执行的第一个任务。

虽然每个Worker的任务是串行处理，但如果创建了多个Worker，因为共用一个workQueue，所以就会并行处理了。

所以根据corePoolSize和maximumPoolSize来控制最大并发数。大致过程可用下图表示。

Java 线程池详解及实例代码

上面的讲解和图来可以很好的理解的这个过程。

如果是做Android开发的，并且对Handler原理比较熟悉，你可能会觉得这个图挺熟悉，其中的一些过程和Handler，Looper，Meaasge使用中，很相似。Handler.send(Message)相当于execute(Runnuble)，Looper中维护的Meaasge队列相当于BlockingQueue，只不过需要自己通过同步来维护这个队列，Looper中的loop()函数循环从Meaasge队列取Meaasge和Worker中的runWork()不断从BlockingQueue取Runnable是同样的道理。

3.管理线程

通过线程池可以很好的管理线程的复用，控制并发数，以及销毁等过程,线程的复用和控制并发上面已经讲了，而线程的管理过程已经穿插在其中了，也很好理解。

在ThreadPoolExecutor有个ctl的AtomicInteger变量。通过这一个变量保存了两个内容：

所有线程的数量每个线程所处的状态其中低29位存线程数，高3位存runState，通过位运算来得到不同的值。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//得到线程的状态
 
private static int runStateOf(int c) {
 
return c & ~CAPACITY;
 
}
 
//得到Worker的的数量
 
private static int workerCountOf(int c) {
 
return c & CAPACITY;
 
}
 
// 判断线程是否在运行
 
private static boolean isRunning(int c) {
 
return c < SHUTDOWN;
 
}

ログイン後にコピー

ここでは主に、shutdown と shutdownNow() によるスレッドプールのシャットダウンプロセスを分析します。まず、スレッドプールにはタスクの追加と実行を制御する 5 つの状態があります。主に次の 3 つのタイプを紹介します:

RUNNING 状態: スレッドプールは正常に実行されており、新しいタスクを受け入れてキュー内のタスクを処理できます。

SHUTDOWN 状態: 新しいタスクは受け入れられなくなりましたが、キュー内のタスクは実行されます。

STOP 状態: 新しいタスクを受け入れなくなり、キュー内のタスクを処理しません。shutdown メソッドは runState を SHUTDOWN に設定し、まだ動作しているスレッドは影響を受けません。そのため、キュー内のタスクは影響を受けません。が実装されることになる。

shutdownNow メソッドは runState を STOP に設定します。 shutdown メソッドとの違いは、このメソッドはすべてのスレッドを終了するため、キュー内のタスクは実行されないことです。

まとめ

ThreadPoolExecutor のソースコードの分析を通じて、スレッドプールの作成、タスクの追加、実行などのプロセスを全体的に理解できます。これらのプロセスに慣れていれば、スレッドプールを使いやすくなります。

同時実行制御の使用と、そこから学んだプロデューサー/コンシューマーモデルのタスク処理は、将来他の関連する問題を理解したり解決したりするのに非常に役立ちます。たとえば、Android の Handler メカニズムや Looper の Messager キューも BlookQueue で処理できることが、ソースコードを読んでわかりました。

上記はJavaスレッドプールに関する情報をまとめたものです。今後も関連情報を追加していきますので、どうぞよろしくお願いいたします。

Java スレッドプールの詳細な説明とサンプルコード関連の記事については、PHP 中国語 Web サイトに注目してください。