Javaのマルチスレッドの概要 - スレッドプール

1つのレディ知識

スレッドプールにどのような執行、ExecutorServiceの、将来、コーラブル、エグゼキュータ、スレッドプールを簡単に見を導入する前に、どのような関係

1.1キュータ

これは、トップレベルのインタフェースのスレッドプールです。それはのための方法を定義し実行し、ボイド（Runnableをします）。

この方法は、発信者が実行可能インターフェースの実装を提供し、サービス処理タスクのための方法であって、サービスメソッドを介して、この実行可能スレッドプールのスレッドを実行する戻り値はありません

1.2 ExecutorServiceの

ExecutorServiceのサブインタフェースExecutorのインターフェースである、それは新しいサービス方法が提出しています、戻り値、（戻り値の型未来の種類があり 将来は1.3を参照してくださいについて の戻り値を提供）、主に呼び出しメソッド呼び出し可能なリターンで提供され値（ 呼び出し可能に1.4を参照 ）、スレッドプールタイプの全ては、このインタフェースを実装します

1.3今後の

名前が示すように、未来は>将来は、スレッドの終了後の結果は、タスクに代わって実行します。
結果は、GETメソッドを介して取得されているスレッドの方法を取得し、そこに取得し、参照することなく参加する2つの方法があります

引数なし T get() - >スレッドの実行の終了を待ってブロックしていない、との結果を得ます。
パラメータがあります T get(long, TimeUnit) -長距離で、ブロッキングスレッドが最後に実行されていない場合>長いスレッドの実行が終了した後の結果を待つときにブロックを修正し、例外をスローします。

1.4呼び出し可能

同様に呼び出し可能、Runnableインタフェースは、それはメソッド呼び出し、および正確Runnable実行と同じ方法でその役割を持っていますが、戻り値はすることはできませんRUN-のRunnable>ノーリターン値のいずれかの例外をスローすることができます呼び出し可能> call-違いがありますチェックされない例外がスローさ

戻り値は、将来のgetメソッドにおけるメソッド呼び出しの戻り値であります

1.5エグゼキューター

執行関係のコレクションとコレクションと同様のユーティリティクラスで、あなたがより簡単に、いくつかのスレッドプールを作成することができ、あなたが直接執行が希望するスレッドプールを得ることができます

2スレッドプール

スレッドプールの状態：実行、がShuttingDown、Termitnaed

• 実行 - スレッドプールが実施されています。アクティブ。
• がShuttingDown - スレッドプールは、プロセスを閉じています。エレガントで閉じました。一度この状態では、スレッドプールは、もはや処理が完了した後、スレッドプールを閉じ、すべてのタスクが受信されたハンドル、新しいタスクを受信して​​いません。
• 終了 - スレッドプールは閉鎖されました。

2.1固定容量スレッドプールFixedThreadPool

FixedThreadPool容量が固定されたスレッドプールで、スレッドプールは、固定容量が作成され、キャリアBlockingQueueのタスクとして使用され、デフォルトのスレッドプールのサイズ制限がInteger.MAX_VALUEであります

• 特徴：タスクの数は、スレッドプールの容量よりも大きい場合、タスクは、空きスレッドがある場合に、タスクキューの実行に格納されていませんが、自動的にタスク実行キューから削除されます
• 使用シナリオ：ほとんどの場合、スレッドプール、優先勧告FixedThreadPoolを使用。OSとハードウェアのシステムは、スレッドキャップによってサポートされています。ない自由で無制限のスレッドプールを提供します。

ここでは戻り値が小さい場合ではありません：
場合は、5の容量を持つスレッドプールを作成し、6がシャットダウン分析メソッドを呼び出して、タスクを実行し、タスクの実装の分析

/**
 * 线程池
 * 固定容量线程池
 */
package com.bernardlowe.concurrent.t08;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Test_02_FixedThreadPool {
	
	public static void main(String[] args) {
		ExecutorService service = 
				Executors.newFixedThreadPool(5);
		for(int i = 0; i < 6; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println("初始状态：" + service);

		System.out.println("开始调用shutdown方法=====");
		service.shutdown();
		// 是否已经结束， 相当于回收了资源。
		System.out.println("是否terminated：" + service.isTerminated());
		// 是否已经关闭， 是否调用过shutdown方法
		System.out.println("是否shutdown：" + service.isShutdown());
		System.out.println("shutdown后的状态：" + service);
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		// service.shutdown();
		System.out.println("2秒过后任务全部执行完====");
		System.out.println("是否terminated：" + service.isTerminated());
		System.out.println("是否shutdown：" + service.isShutdown());
		System.out.println("任务全部执行完过后状态：" + service);
	}

}


复制代码

結果：

次の手順では、図から分析することができ
、実行の5つのスレッド、キューにタスク、タスク0：初期状態では
↓
シャットダウン（と呼ばれ、スレッドプールが閉じていない（falseにと終了）：シャットダウンメソッドを呼び出した後もはや、タスクを完了するために、0、）新しいタスクを受信しない
↓
タスクが完了した後に2秒：スレッドプールは）真として終了（閉じられた、タスクを完了するために、（もはや新しいタスクを受信しない）、シャットダウンを呼び出す6

ここでは、小さなケースの戻り値は次のとおりです。ケースは1の容量を持つスレッドプールを作成し、転送方法コーラブルを提出し、将来の取得スレッドの戻り値が取得します

/**
 * 线程池
 * 固定容量线程池（有返回值）
 */
package com.bernardlowe.concurrent.t08;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class Test_03_Future {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		ExecutorService service = Executors.newFixedThreadPool(1);

		Future<String> future = service.submit(new Callable<String>() {
			@Override
			public String call() {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				return Thread.currentThread().getName() + " - test executor";
			}
		});
		System.out.println("线程是否结束: " + future.isDone()); // 查看线程是否结束， 任务是否完成。 call方法是否执行结束

		System.out.println("call方法的返回值: " + future.get()); // 获取call方法的返回值。
		System.out.println("线程是否结束: " + future.isDone());

		// 关闭线程池
		service.shutdown();
	}

}

复制代码

結果：

2.2 CachedThreadPool

キャッシュされたスレッドプール、容量制限（Integer.MAX_VALUEで）、自動拡張
容量管理戦略：プール内のスレッドの数は、タスクの実行を満たしていない場合は、新しいスレッドを作成します。新しいタスクを直ちに処理することができないがあるたびに、新しいスレッドを作成します。アイドル・スレッドプールのスレッドの長さがある臨界値（デフォルトは60秒）に達すると、自動的方法によって得られたスレッドプールはExecutors.newCachedThreadPool（）アイドルタイム、以下に示す具体的な理由によって変更することができないスレッドを解放するが、あることができますカスタムスレッドプールThreadPoolExecutorの変更は、特定のメソッド2.5は、ここで説明されていません

シナリオ：社内アプリケーションやテストアプリケーション。

• 内部アプリケーション、条件付きの瞬間など、内部のデータ処理アプリケーション、：データ削減を実行するために夜間の電気通信プラットフォーム（短い時間で処理してくださいすべての作業を、ハードウェアとソフトウェアに十分な自信があります）。
• テスト中のアプリケーションのテスト、ハードウェアまたはソフトウェアの最高負荷を取得しようと、FixedThreadPoolを提供する能力を導くために使用さ

ケースプレゼンテーション：

/**
 * 线程池
 * 无容量限制的线程池（最大容量默认为Integer.MAX_VALUE）
 */
package com.bernardlowe.concurrent.t08;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Test_05_CachedThreadPool {
	
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		
		System.out.println(service);
		
		for(int i = 0; i < 5; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println(service);
		
		try {
			TimeUnit.SECONDS.sleep(65);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(service);
	}

}

复制代码

2.3スケジュールされたタスク、スレッドプールScheduledThreadPool

ScheduledThreadPoolスレッドプールがスケジュールされたタスクである、あなたがスレッドプールを計画するために応じてタスクを自動化することができ、基礎となる実装はDelayedWorkQueue、その主な方法scheduleAtFixedRateの一つです

これは、次のパラメータがあります。

• コマンド - タスクが実行されます
• initialDelayの - タスクの第1の時間間隔。
• 期間 - タスクは、間隔をあけて複数回行いました。
• 単位 - 時間単位の複数のタスクの実行間隔。

ケース：

/**
 * 线程池
 * 计划任务线程池。
 */
package com.bernardlowe.concurrent.t08;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test_07_ScheduledThreadPool {
	
	public static void main(String[] args) {
		ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
		System.out.println(service);
		
		// 定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
		// runnable - 要执行的任务。
		service.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			}
		}, 0, 300, TimeUnit.MILLISECONDS);
		
	}

}

复制代码

2.4容量の単一スレッドプールSingleThreadExecutor

シングルスレッドプールの容量、使用状況やFixedThreadPool似ていますが、同じとnewFixedThreadPool newSingleThreadExecutorスレッドプールはFinalizableDelegatedExecutorServiceはラッパー作成されていない
SingleThreadExecutorまとめました：

• シングルラインタスク処理スレッドプール
• シャットダウン方法は、必然的に呼び出されます
• ThreadPoolExecutorスレッドプールのすべての機能はありません
  コンクリートがこの記事を見ることができます：https://www.jianshu.com/p/2b7d853322bb

2.5ブランチは、スレッドプールをマージForkJoinPool

支店は、再帰的に必要な分岐がサブタイプForkJoinTaskタイプのForkJoinTaskタイプでなければならないタスクを組み合わせて提供することができます2つの抽象のサブタイプを、複雑なタスクを処理するのに適した複雑なタスクを実行することができ、スレッドプールを（同様のデザインをmapduce）マージ：
RecursiveTaskが戻ってきました枝は、タスク結果のマージ
RecursiveActionは枝がタスクをマージ結果が返しません

ケース：このケースはあったが、MAX_SIZE = 50000、計算開いて新しいスレッドのタスクよりも大きい番号の範囲を計算し、最後にマージ統計を実現ForkJoinPool累積データ

/**
 * 线程池
 * 分支合并线程池。
 */
package com.bernardlowe.concurrent.t08;

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class Test_08_ForkJoinPool {
	
	final static int[] numbers = new int[1000000];
	final static int MAX_SIZE = 500000;
	final static Random r = new Random();
	
	
	static{
		for(int i = 0; i < numbers.length; i++){
			numbers[i] = r.nextInt(1000);
		}
	}
	
	static class AddTask extends RecursiveTask<Long>{ // RecursiveAction
		int begin, end;
		public AddTask(int begin, int end){
			this.begin = begin;
			this.end = end;
		}
		
		// 
		protected Long compute(){
			if((end - begin) < MAX_SIZE){
				long sum = 0L;
				for(int i = begin; i < end; i++){
					sum += numbers[i];
				}
				// System.out.println("form " + begin + " to " + end + " sum is : " + sum);
				return sum;
			}else{
				int middle = begin + (end - begin)/2;
				AddTask task1 = new AddTask(begin, middle);
				AddTask task2 = new AddTask(middle, end);
				task1.fork();// 就是用于开启新的任务的。 就是分支工作的。 就是开启一个新的线程任务。
				task2.fork();
				// join - 合并。将任务的结果获取。 这是一个阻塞方法。一定会得到结果数据。
				return task1.join() + task2.join();
			}
		}
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException, IOException {
		long result = 0L;
		for(int i = 0; i < numbers.length; i++){
			result += numbers[i];
		}
		System.out.println(result);
		
		ForkJoinPool pool = new ForkJoinPool();
		AddTask task = new AddTask(0, numbers.length);
		
		Future<Long> future = pool.submit(task);
		System.out.println(future.get());
		
	}

}

复制代码

結果：4スレッドのタスクの分類タスクが計算され、最後の要約

2.5 ThreadPoolExecutor

ThreadPoolExecutor実装スレッドプールの底、ForkJoinPool付加、他の一般的に使用されるThreadPoolExecutorスレッドプールの底は、以下のような構造を有し、実装されています。

• corePoolSize：コア能力は、スレッドプール、デフォルトのスレッド数を作成します。スレッドプール内のスレッドの最小数が保たれています
• maximumPoolSize：最大容量は、スレッドプールは、スレッドの最大数を持っています
• keepAliveTimeが：ライフサイクル、0は永久的です。スレッドが長く、自動回復アイドル状態のとき
• 単位：秒、ミリ秒：ライフ・サイクル・ユニット、ユニットのような、ライフサイクルを提供します
• ワークキューのタスクキュー、キューを遮断します。ジェネリック医薬品は、Runnableをでなければならないことに注意してください

ケース：

/**
 * 线程池
 * 固定容量线程池
 */
package com.bernardlowe.concurrent.t08;

import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test_09_ThreadPoolExecutor {
	
	public static void main(String[] args) {
		// 模拟fixedThreadPool， 核心线程5个，最大容量5个，线程的生命周期无限。
		ExecutorService service = 
				new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, 
						new LinkedBlockingQueue<Runnable>());
		
		for(int i = 0; i < 6; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println(service);
		
		service.shutdown();
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		service.shutdown();
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
		
	}
}

复制代码