Tomcatはスレッドプールを使用してリモート同時リクエストを処理します。

sun.misc.安全でない
java.util.concurrent.ThreadPoolExecutor
java.util.concurrent.ThreadPoolExecutor.ワーカー
java.util.concurrent.locks.AbstractQueuedSynchronizer
java.util.concurrent.locks.AbstractQueuedLongSynchronizer
java.util.concurrent.LinkedBlockingQueue

org.apache.tomcat.util.net.Nioエンドポイント
org.apache.tomcat.util.threads.ThreadPoolExecutor
org.apache.tomcat.util.threads.タスクスレッドファクトリー
org.apache.tomcat.util.threads.タスクキュー

パブリックスレッドプールエグゼキュータ(
 int コアプールサイズ、
 int 最大プールサイズ、
 長いkeepAliveTime、
 TimeUnit 単位、
 BlockingQueue<Runnable> ワークキュー、
 スレッドファクトリー スレッドファクトリー、
 RejectedExecutionHandler ハンドラー) {
 
}

パブリック void createExecutor() {
 内部エグゼキュータ = true;
 タスクキュー taskqueue = 新しいタスクキュー();
 //TaskQueue は無制限のキューであり、いつでも追加できるため、ハンドラーは無効な TaskThreadFactory と同等です。tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
 executor = 新しい ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
 taskqueue.setParent( (ThreadPoolExecutor) executor);
 }

パブリック int prestartAllCoreThreads() {
 整数n = 0;
 (addWorker(null, true)) の間
  ++n;
 n を返します。
 }

パブリック void execute(実行可能なコマンド) {
 if (コマンド == null)
  新しい NullPointerException() をスローします。
 
 ctl.get(); を呼び出します。
 	// ワーカーの数はコア スレッドの数より少ないですか? Tomcat での初期化後、通常は最初の条件は満たされず、addWorker は呼び出されません。
 ワーカー数(c) < コアプールサイズの場合
  if (addWorker(コマンド、true))
  戻る;
  ctl.get() 関数は、次のコードで使用できます。
 }
 	// workQueue.offer(command) タスクをキューに追加します。
 if (isRunning(c) && workQueue.offer(command)) {
  int 再チェック = ctl.get();
  if (!isRunning(再確認) && remove(コマンド))
  拒否(コマンド);
  そうでない場合 (workerCountOf(recheck) == 0)
  ワーカーを追加します(null、false);
 }
 そうでない場合 (!addWorker(command, false))
  拒否(コマンド);
 }

パブリックブールオファー(E e) {
 e == null の場合、新しい NullPointerException() をスローします。
 最終的な AtomicInteger count = this.count;
 count.get() == 容量の場合
 false を返します。
 c = -1;
 ノード<E> ノード = 新しいノード<E>(e);
 最終的な ReentrantLock putLock = this.putLock;
 ロックを置きます。
 試す {
 count.get() が容量未満の場合
  enqueue(node); //ここでキューにタスクを追加します c = count.getAndIncrement();
  (c + 1 < 容量)の場合
  シグナルが満杯でない。
 }
 ついに
 ロックを解除します。
 }
 (c == 0)の場合
 シグナルが空でない();
 c >= 0 を返します。
}

// タスクをキューに追加します/**
 * キューの最後にノードをリンクします。
 *
 * @param node ノード
 */
プライベートvoidエンキュー(Node<E>ノード) {
 // putLock.isHeldByCurrentThread() をアサートします。
 // last.next == null であることを確認します。
 last = last.next = node; //リンクリスト構造last.next = node; last = node
}

/** メイン実行ループを外側の runWorker に委譲します */
 パブリックボイド実行() {
  実行ワーカー(これを);
 }

最終的なvoid runWorker(ワーカーw) {
 スレッド wt = Thread.currentThread();
 実行可能なタスク = w.firstTask;
 w.firstTask = null;
 w.unlock(); // 割り込みを許可する
 ブール値completedAbruptly = true;
 試す {
  while (task != null || (task = getTask()) != null) { // キュー内のタスクを取得するためにループします w.lock(); // ロックします try {
   //実行前処理 beforeExecute(wt, task);
   //キュー内のタスクはtask.run()の実行を開始します。
   // 後処理を実行します afterExecute(task, throw);
  ついに
   タスク = null;
   完了したタスク++;
   w.unlock(); // ロックを解除する}
  }
  突然完了 = false;
 ついに
  processWorkerExit(w, 突然完了);
 }
 }

パブリックブールオファー(E e) {
 e == null の場合、新しい NullPointerException() をスローします。
 最終的な AtomicInteger count = this.count;
 count.get() == 容量の場合
  false を返します。
 c = -1;
 ノード<E> ノード = 新しいノード<E>(e);
 最終的な ReentrantLock putLock = this.putLock;
 putLock.lock(); //ロックしてみる{
  count.get() が容量未満の場合
  エンキュー(ノード);
  カウントの取得と増分();
  (c + 1 < 容量)の場合
   シグナルが満杯でない。
  }
 ついに
  putLock.unlock(); //ロックを解除する}
 (c == 0)の場合
  シグナルが空でない();
 c >= 0 を返します。
 }

プライベート実行可能getTask() {
 boolean timedOut = false; // 最後の poll() はタイムアウトしましたか?
		// ...省略 for (;;) {
  試す {
  実行可能 r = 時間制限あり ?
   workQueue.poll(keepAliveTime、時間単位.NANOSECONDS):
   workQueue.take(); //キュー内のタスクを取得する if (r != null)
   r を返します。
  タイムアウト = true;
  } catch (InterruptedException 再試行) {
  タイムアウト = false;
  }
 }
 }
パブリックE take()はInterruptedExceptionをスローします{
 元;
 c = -1;
 最終的な AtomicInteger count = this.count;
 最終的な ReentrantLock takeLock = this.takeLock;
 takeLock.lockInterruptibly(); // ロックを試みる {
  count.get() == 0 の間
  notEmpty.await(); //キューにタスクがない場合は待機します}
  x = デキュー();
  c = count.getAndDecrement();
  (c > 1)の場合
  空ではないシグナル();
 ついに
  takeLock.unlock(); // ロックを解除する}
 (c == 容量)の場合
  シグナルが満杯でない();
 x を返します。
 }

保護された最終的なブール値の compareAndSetState(int expect, int update) {
 // これをサポートするための組み込み関数の設定については以下を参照してください
 unsafe.compareAndSwapInt(this、stateOffset、expect、update) を返します。
 }

//対応するJavaの最下層は実際にはネイティブメソッドであり、C++コードに対応しています/**
* Java変数が現在<tt>x</tt>である場合、アトミックに更新します。
* <tt>期待どおり</tt>を保持します。
* 成功した場合は @return <tt>true</tt>
*/
パブリックファイナルネイティブブールcompareAndSwapInt(Object o, long offset,
      int が期待される、
      整数x);

// ブロッキングスレッドを追加する private Node addConditionWaiter() {
  ノード t = lastWaiter;
  // lastWaiter がキャンセルされた場合は、クリーンアップします。
  if (t != null && t.waitStatus != Node.CONDITION) {
  リンク解除CancelledWaiters();
  t = 最後のウェイター;
  }
  ノード node = new Node(Thread.currentThread(), Node.CONDITION);
  t == nullの場合
  firstWaiter = ノード;
  それ以外
  t.nextWaiter = ノード;
  lastWaiter = node; // 新しくブロックされたスレッドをリンク リストの最後に配置します。 return node;
 }

// ブロックされたスレッドを取り出す public final void signal() {
  if (!isHeldExclusively())
  新しい IllegalMonitorStateException() をスローします。
  Node first = firstWaiter; //リンクリスト内の最初のブロックされたスレッド if (first != null)
  doSignal(最初に);
 }

//取得後、このスレッドを起動します final boolean transferForSignal(Node node) {
  LockSupport.unpark(node.thread);
 true を返します。
 }
パブリック静的void unpark(スレッドスレッド) {
 （スレッド！= null）の場合
  UNSAFE.unpark(スレッド);
 }