1、エグゼキュータ
public interface Executor {
// 执行Runnable任务
void execute(Runnable command);
}ExecutorServiceの：
- これは、呼び出し可能ないくつかのタスクを提出する方法、サポートを提供します
- これは、インターフェース・スレッド・プールに関連するオペレーションを定義します
public interface ExecutorService extends Executor {
// 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
void shutdown();
/**
* 立即关闭执行器, 主要有以下特点:
* 1. 尝试停止所有正在执行的任务, 无法保证能够停止成功, 但会尽力尝试(例如, 通过 Thread.interrupt中断任务, 但是不响应中断的任务可能无法终止);
* 2. 暂停处理已经提交但未执行的任务;
*
* @return 返回已经提交但未执行的任务列表
*/
List<Runnable> shutdownNow();
// 如果此执行程序已关闭，则返回true。
boolean isShutdown();
// 仅当执行器已关闭且所有任务都已经执行完成, 才返回true.
boolean isTerminated();
// 阻止所有任务在关闭请求之后完成执行，或者发生超时，或者当前线程被中断，以先发生者为准
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
// 接收Callable实现，返回Future对象
<T> Future<T> submit(Callable<T> task);
// 提交Runnable任务以执行并返回表示该任务的Future。
<T> Future<T> submit(Runnable task, T result);
// 提交Runnable任务以执行并返回表示该任务的Future
// 注意: Future的get方法在成功完成时将会返回null.
Future<?> submit(Runnable task);
// 执行给定集合中的所有任务, 当所有任务都执行完成后, 返回保持任务状态和结果的 Future 列表.
// 注意: 该方法为同步方法. 返回列表中的所有元素的Future.isDone() 为 true.
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
// 执行给定集合中的所有任务, 当所有任务都执行完成后或超时期满时（无论哪个首先发生）
// 返回保持任务状态和结果的 Future 列表.
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
// 执行给定集合中的任务, 只有其中某个任务率先成功完成（未抛出异常）, 则返回其结果
// 一旦正常或异常返回后, 则取消尚未完成的任务.
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
// 执行给定集合中的任务, 如果在给定的超时期满前, 某个任务已成功完成（未抛出异常）, 则返回其结果.
// 一旦正常或异常返回后, 则取消尚未完成的任务.
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}AbstractExecutorService：
- 種々の重合の入り口の提出、さまざまなタスクの包装RunnableFuture、統一されたコール
execute(RunnableFuture ftask); - さまざまな達成
invoke*コール・ロジック重合をdoInvokeAny
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}ScheduledExecutorService：
アクチュエータの一部のタスクは、定期的に実行またはスケジュールすることができます
public interface ScheduledExecutorService extends ExecutorService {
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
long initialDelay,
long period,
TimeUnit unit);
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit);
}執行：
- スレッドプールの工場機能を提供
- オペレーティングスレッドプールが作成されます
Coreは、作成しました：
- 長い治療の必要性、アイドル状態のスレッドを再利用するための柔軟性、そうでない場合はリサイクル可能な、新しいスレッドの場合よりもキャッシュスレッドプール、スレッドプールを作成newCachedThreadPool。
- 固定サイズのスレッドプールを作成newFixedThreadPool、あなたは同時スレッドの最大数を制御することができ、余分なスレッドは、キュー内で待機します。
- 定期的かつ定期的なタスクの実行をサポートするために、固定サイズのスレッドプールを作成newScheduledThreadPool
- newSingleThreadExecutorシングルスレッドのスレッドプールを作成し、それだけですべてのタスクが指定された順（FIFO、LIFO、優先順位）で実行されることを保証する唯一のワーカースレッドタスクを実行するために使用します。
コアAPI：
1、（Runnableをコマンド）を実行：タスクのRuannableタイプ果たす
コーラブルかのRunnableタスクを送信するために使用され、このタスクを表すFutureオブジェクトを返します（タスク）提出、2を
3に、シャットダウン（）：タスクを完了した後に提出されました新しいタスクを引き継ぐないクローズド作業、
4は、shutdownNowの（）：全てのタスクが実行されて停止し、閉じられた作品。
5、isTerminated（）：すべてのタスクが満たされているかどうかをテスト。
6、isShutdown（）：ExecutorServiceのが閉じられたかどうかをテストします。
コアのパラメータ：
- corePoolSize：アイドルスレッドを含むプールに保持するスレッド数、
- maximumPoolSize：プールで許可されるスレッドの最大数
- keepAliveTimeが：スレッドの数がコアよりも大きい場合、これは最大時間の新しいタスクを待っている余分なアイドルスレッドの前に終了されます
- 単位：時間単位のkeepAliveTimeがパラメータ
- ワークキュー：キューを維持するためのタスクを実行する前に。このキューは、executeメソッドにより提出されたRunnableタスクを保持しています
- 工場出荷時の使用実行手順の新しいスレッドを作成：threadFactory
- ハンドラ：スコープからスレッドと実行キューの容量理由
オペレーティングロジック：
- 現在のプールのサイズならば、corePoolSizeよりも少ないプールサイズ、新しいスレッドがタスクを実行するために作成されます
- プールサイズcorePoolSizeよりも大きい現在のプールサイズ、および待機キューが満杯でない場合、プロセスはキューに進み、
- maximumPoolSizeよりも、現在のプールサイズ、プールサイズcorePoolSizeよりも大きいと小さい場合は、キューがいっぱいです、タスクを実行する新しいスレッドを作成
- キューがいっぱいになるmaximumPoolSizeよりも、現在のプールサイズ、プールサイズcorePoolSizeより大きく、大きい場合、及び、政策を拒否呼び出します
- タスクを実行した後、プール内の各スレッドはすぐに終了しませんが、keepAliveTimeが年、スレッドが終了で新しいタスクを待たない場合は、ねじのタスクは、実行する必要があるかどうかを確認するために次のキューを待ちます
2、の原則の実装
設定パラメータ：
/**
* 使用给定的参数创建ThreadPoolExecutor.
*
* @param corePoolSize 核心线程池中的最大线程数
* @param maximumPoolSize 总线程池中的最大线程数
* @param keepAliveTime 空闲线程的存活时间
* @param unit keepAliveTime的单位
* @param workQueue 任务队列, 保存已经提交但尚未被执行的线程
* @param threadFactory 线程工厂(用于指定如何创建一个线程)
* @param handler 拒绝策略 (当任务太多导致工作队列满时的处理策略)
*/ThreadPoolExecutor論理的に自己管理スレッド・プールは2つの部分に分かれています。
- コアスレッドプール（サイズがcorePoolSizeに相当します）、
- 非コアスレッドプール（corePoolSize-maximumPoolSizeのサイズに対応します）。
あなたがスレッドプールにジョブを送信すると、それは、ワーカースレッドが作成されます-と呼ばれる労働者を、労働者が、論理的に、具体的に属する、次の図[コア]または[非中核のスレッドプールのスレッドプール]に所属します判定corePoolSize、maximumPoolSize、労働者の合計
[コア] [非コアスレッドプールスレッドプールは】論理的な概念は、ThreadPoolExecutorタスクスケジューリング処理が基づいているcorePoolSizeとmaximumPoolSizeサイズは、タスクをスケジュールする方法を決定すべきです
どのように動作します：
内部ThreadPoolExecutorは、可変のAtomicInteger定義- CTL、ビット単位によって分割し、スレッドプールスレッドの状態変数に記録機能- 保存されたスレッド数の下位29ビット、高い3つのスレッドプールの状態保存します：
/**
* 保存线程池状态和工作线程数:
* 低29位: 工作线程数
* 高3位 : 线程池状态
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
// 最大线程数: 2^29-1
private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 00011111 11111111 11111111 11111111
// 线程池状态
// 11100000 00000000 00000000 00000000
private static final int RUNNING = -1 << COUNT_BITS;
// 00000000 00000000 00000000 00000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 00100000 00000000 00000000 00000000
private static final int STOP = 1 << COUNT_BITS;
// 01000000 00000000 00000000 00000000
private static final int TIDYING = 2 << COUNT_BITS;
// 01100000 00000000 00000000 00000000
private static final int TERMINATED = 3 << COUNT_BITS; あなたが見ることができる、ThreadPoolExecutorは、スレッドプールの状態の5種類が定義されています。
- RUNNING：新しいタスクを受け入れ、そしてプロセスはタスクキューのブロックに入っています
- SHUTDOWN：新しいタスクを受け入れていないが、プロセスは、タスクキューのブロックに入っています
- STOP：実行中のタスクを中断しながら、タスクを処理せずに新しいタスクを受け入れないが、ブロッキングキューに入っています
- 片付け：すべてのタスクが終了している、ワーカースレッドの数はゼロ、終了片付けや準備方法呼び出しにスレッドです
- TERMINATED：終了メソッドの実行が完了しました
HashSetのことで内部のメンテナンス労働者
/**
* 工作线程集合.
*/
private final HashSet<Worker> workers = new HashSet<Worker>();ワーカー：
/**
* Worker表示线程池中的一个工作线程, 可以与任务相关联.
* 由于实现了AQS框架, 其同步状态值的定义如下:
* -1: 初始状态
* 0: 无锁状态
* 1: 加锁状态
*/
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
/**
* 与该Worker关联的线程.
*/
final Thread thread;
/**
* Initial task to run. Possibly null.
*/
Runnable firstTask;
/**
* Per-thread task counter
*/
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // 初始的同步状态值
this.firstTask = firstTask;
// 每个worker对象会调用线程工厂，
this.thread = getThreadFactory().newThread(this);
}
/**
* 执行任务
*/
public void run() {
runWorker(this);
}
/**
* 是否加锁
*/
protected boolean isHeldExclusively() {
return getState() != 0;
}
/**
* 尝试获取锁
*/
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
/**
* 尝试释放锁
*/
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() {
acquire(1);
}
public boolean tryLock() {
return tryAcquire(1);
}
public void unlock() {
release(1);
}
public boolean isLocked() {
return isHeldExclusively();
}
/**
* 中断线程(仅任务非初始状态)
*/
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}スレッドファクトリ：
以下は、デフォルトのスレッドファクトリです
public static ThreadFactory defaultThreadFactory() {
return new DefaultThreadFactory();
}
/**
* 默认的线程工厂.
*/
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}実装プロセスを通じて、次の2点を実行するためのキーです。
- ワーカースレッドの数がコアスレッドプールの上限（CorePoolSize）よりも小さい場合は、直接、新しいスレッドや作業タスクを作成します。
- 労働者の数が以上CorePoolSizeスレッド場合は、タスクを実行しようと後でキュー待ちに追加。あなたは（たとえば、キューの場合は、いっぱいです）キューに参加しなかった場合、一般的なスレッドプールの下でいっぱいではありません（
CorePoolSize ≤ 工作线程数 ＜ maximumPoolSize）新しいワーカースレッドを作成するには、すぐにタスクを実行し、そうでない政策を否定します。
ワーカースレッドのライフサイクル
拒否した戦略：
ThreadPoolExecutorは、次の2つのケースでの戦略を実行することを拒否します。
- コアスレッドプールは、（非コアスレッドプールに起因する）ワーカースレッドを作成することがいっぱいでない、タスクキューも満杯であれば、非コアスレッドプールの最初の判断がいっぱいありません、いっぱいになると、それ以外の場合には、戦略を実行することを拒否します。
- タスクを送信すると、ThreadPoolExecutorは終了しました。
拒否戦略の4種類：
- AbortPolicy（デフォルト）：AbortPolicy戦略が実際にスローされRejectedExecutionException異常を
- DiscardPolicy：実際にDiscardPolicyポリシー不作為、何もしない、と彼らは回復してきた他のタスク
- DiscardOldestPolicy：DiscardOldestPolicy戦略は最近、タスクキューにタスクを滴下し、現在のタスクを実行しました
- CallerRunsPolicy：CallerRunsPolicy戦略は、新しいジョブ送信の速度を遅くすることができますタスクを実行するための独自のスレッド、と等価です
図3に示すように、ソースコード解析：
建設：
ExecutorService executorService = Executors.newFixedThreadPool(100);ThreadPoolExecutorインスタンスを作成：
// 创建ThreadPoolExecutor
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
// 指定默认的线程创建工厂和拒绝策略
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
/**
* 使用给定的参数创建ThreadPoolExecutor.
*
* @param corePoolSize 核心线程池中的最大线程数
* @param maximumPoolSize 总线程池中的最大线程数
* @param keepAliveTime 空闲线程的存活时间
* @param unit keepAliveTime的单位
* @param workQueue 任务队列, 保存已经提交但尚未被执行的线程
* @param threadFactory 线程工厂(用于指定如何创建一个线程)
* @param handler 拒绝策略 (当任务太多导致工作队列满时的处理策略)
*/
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;
}ミッション：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// CASE1: 工作线程数 < 核心线程池上限
if (workerCountOf(c) < corePoolSize) {
// 添加工作线程并执行
if (addWorker(command, true))
return;
c = ctl.get();
}
// 如果工作队列未满，再次检查运行状态，并插入到任务
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 再次check判断运行状态如果是非运行状态就移除出去&reject掉
if (!isRunning(recheck) && remove(command))
reject(command);
// 发现可能运行线程数是0那么增加一个null的worker
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 直接增加worker如果不成功直接reject
else if (!addWorker(command, false))
reject(command);
}addWorker（）
/**
* 添加工作线程并执行任务
*
* @param firstTask 如果指定了该参数, 表示将立即创建一个新工作线程执行该firstTask任务;
否则复用已有的工作线程，从工作队列中获取任务并执行
* @param core 执行任务的工作线程归属于哪个线程池: true-核心线程池 false-非核心线程池
*/
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
// 获取线程池状态
int rs = runStateOf(c);
/**
* 这个if主要是判断哪些情况下, 线程池不再接受新任务执行
* 1. 线程池状态为 STOP 或 TIDYING 或 TERMINATED: 线程池状态为上述任一一种
* 2. 线程池状态 ≥ SHUTDOWN 且 firstTask != null:
因为当线程池状态 ≥ SHUTDOWN时, 不再接受新任务的提交，所以直接返回
* 3. 线程池状态 ≥ SHUTDOWN 且 队列为空
队列中已经没有任务了, 所以也就不需要执行任何任务了，可以直接返回
*/
if (rs >= SHUTDOWN &&
!(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
// 检查容量是否超出
// 1. 超出最大容量；2、core为true表示核心线程数量，为false表示非核心线程数量
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 增加worker数量
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 {
// 创建worker(AQS)
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();
// 添加到worker队列中
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 开始执行任务
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
// 添加worker失败处理
addWorkerFailed(w);
}
return workerStarted;
}ワーカーを開始した後、（）の実行を呼び出します
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 {
// 当task==null时会通过getTask从队列取任务
while (task != null || (task = getTask()) != null) {
w.lock();
/**
* 下面这个if判断的作用如下:
* 1.保证当线程池状态为STOP/TIDYING/TERMINATED时，
当前执行任务的线程wt是中断状态(因为线程池处于上述任一状态时，均不能再执行新任务)
* 2.保证当线程池状态为RUNNING/SHUTDOWN时，当前执行任务的线程wt不是中断状态
*/
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 执行前置处理, 1.8版本为空实现
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 {
// 执行后置处理, 1.8版本为空实现
afterExecute(task, thrown);
}
} finally {
task = null;
// 更新该worker完成状态
w.completedTasks++;
w.unlock();
}
}
// 执行到此处, 说明该工作线程自身既没有携带任务, 也没从任务队列中获取到任务
// 正常退出时，为false, 如果抛出异常退出，则为true
completedAbruptly = false;
} finally {
// 处理工作线程的退出工作
processWorkerExit(w, completedAbruptly);
}
} processWorkerExit(Worker w, boolean completedAbruptly)
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 工作线程因异常情况而退出
if (completedAbruptly)
// 工作线程数减1(如果工作线程执行时没有出现异常, 在getTask()方法中已经对线程数减1了)
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// completedTaskCount记录线程池完成的总任务数
completedTaskCount += w.completedTasks;
// 从工作线程集合中移除(该工作线程会自动被GC回收)
workers.remove(w);
} finally {
mainLock.unlock();
}
// 根据线程池状态, 判断是否需要终止线程池
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
// 工作线程为正常退出
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 新建一个工作线程
addWorker(null, false);
}
}4、のScheduledThreadPoolExecutor
ディレイ/サイクルスケジューリング機能のタスクを満たすために、それがに詰め、すべてのRunnableタスクがパッケージされている必要がありますRunnableScheduledFuture作業。
- ScheduledThreadPoolExecutorのタスクキューは、特殊なキュー遅延であります
- DelayedWorkQueue：それは似てDelayQueueが、チームのすべての要素が実装しなければならないことを要求RunnableScheduledFutureのインターフェイスを。
の原則の実装
建設：
ScheduledThreadPoolExecutorのコンストラクタ、呼び出しが親の内部で実際にThreadPoolExecutorのコンストラクタ、ここで最も重要な問題は、タスクキューを選択することです- DelayedWorkQueue
スケジュール：
コアスケジューリング方法schedule、scheduleAtFixedRate、scheduleWithFixedDelay
1、包装ScheduledFutureTaskのタスク
2、ステータス決意、DelayedWorkQueueにタスクを追加
- まず第一に、タスクはスレッドプールに提出されていない場合、それは、スレッドプールの状態を判断しますRUNNINGポリシー状態は拒否を実行します。
- その後、ブロッキングキューにタスクを追加します。（DelayedWorkQueueがアンバウンド形式のキューであるため、それがすることに注意してください追加成功）
- その後、ワーカースレッドを作成し、スレッドプールは、コアまたは非コアスレッドプールに追加されます
コアスレッド・プールが満杯になった場合は、新しいワーカースレッドは、スレッドプールのコアに配置されます。コアスレッド・プールが満杯になった場合は、ScheduledThreadPoolExecutorのはThreadPoolExecutorなどの非中核に起因するワーカースレッドプールのスレッドを作成するために行くが、直接返されませんでした。つまり、コア・スレッド・プールが満杯になるとScheduledThreadPoolExecutorの中で、それはワーカースレッドを作成するために行くことはありません。
生産実践
どのように合理的なスレッドプールのサイズを設定するには？
タスクの特性の分析：
- CPU集中型のタスク、IO集約型のタスク、ハイブリッドミッション：タスクの自然。
- 優先度のタスク：高、中、低。
- ロング、ミディアム、ショート：タスクの実行時間。
- 依存タスク：データベース接続などの他のシステムリソースに依存するかどうか。
- CPU集約型のタスクがCPUの数を設定するようなスレッドの数として小さいスレッドとして構成されるべきである+1
- このような構成として、スレッド、CPU +1の二倍の数の数を増やす必要がIO操作は、CPUが引退してみましょうと座っていない、CPUを占有していないとして、IO集約型のタスクは、できるだけ多くのスレッドを使用して設定する必要があります
- あなたが分割することができた場合にハイブリッドミッションについては、それぞれ、IO集約型とCPU集中処理に分け、両方の実行時間がほぼ同じである処理時間が大きな違いであるならば、それを分割する必要はないことを条件とします
- タスクは、このようなデータベース接続の結果に依存タスクなど、他のシステムリソースに依存関係が、返された場合は、この時間は待ち時間長く、CPUのアイドル時間が長く、スレッドの数が多いほど、より良いするために設定する必要がありますCPUを使用しました。
スレッドプールサイズの合理的な計算式を設定します。
最佳线程数目 = （（线程等待时间+线程CPU时间）/ 线程CPU时间 ）* CPU数目
：
最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1）* CPU数目
結論：高い割合、より多くのスレッドに必要性を待つスレッド。スレッドのCPU時間は、より高い比率を占めていた、あまり必要のスレッド
同時の場合、スレッドプールの構成：
- 高い同時実行、タスク構成など、いくつかのスレッドの短い実行時間：CPUのコア数+ 1
- システムの大きな圧力のための高同時実行、タスクの長年の業務執行は、スレッドプールの設定を解決するのではなく、アーキテクチャにより、可能な限り最適化する必要があります。たとえば、非同期のクリッピングにデカップリング
- 並行性は高くないが、長いサービス時間：
- タスクがIO操作で消費長い時間であれば、スレッドプールの数を増やす必要があり、CPUが引退し、座っていない、より多くのタスクを実行してみてください
- タスクは、消費の計算に長い時間である場合、スレッドの数をカウントCPUスレッド、およびCPUコアの一貫したセットを切り替えることによって低減されるべきです。
「戦闘でのJava並行処理。」
Nthreads = NCPU * UCPU * (1 + W/C)
どこで：
NCPUはRuntime.getRuntime（）により製造することができるプロセッサコアの数。AvailableProcessors（）が与えることです
UCPUのCPU使用率は、（ゼロとの間に、値が1の間であるべきである）ことが望まれます
W / Cは、待機時間の割合と算出した時間であります
CPU集約型の、永続的なコアスレッドが存在する設定：優先度のタスクは、カーネルスレッドの数を決定するので、資源の浪費を避けるために、作成するには不十分です
CPU集約型のタスクは、パフォーマンスに影響を与える、キューのブロッキングキュー、CPU集約型の並行性の高いシナリオCAS資源の大規模な数を選択します。