Tomcat verwendet Thread-Pool zur Verarbeitung gleichzeitiger Remote-Anfragen

sun.misc.Unsicher
java.util.concurrent.ThreadPoolExecutor
java.util.concurrent.ThreadPoolExecutor.Worker
java.util.concurrent.locks.AbstractQueuedSynchronizer
java.util.concurrent.locks.AbstractQueuedLongSynchronizer
java.util.concurrent.LinkedBlockingQueue

org.apache.tomcat.util.net.NioEndpoint
org.apache.tomcat.util.threads.ThreadPoolExecutor
org.apache.tomcat.util.threads.TaskThreadFactory
org.apache.tomcat.util.threads.TaskQueue

öffentlicher ThreadPoolExecutor(
 int corePoolSize,
 int maximalePoolgröße,
 lange KeepAliveTime,
 TimeUnit-Einheit,
 BlockingQueue<Ausführbare Datei> workQueue,
 ThreadFactory ThreadFactory,
 RejectedExecutionHandler-Handler) {
 
}

öffentliche Leere createExecutor() {
 internalExecutor = wahr;
 TaskQueue taskqueue = neue TaskQueue();
 //TaskQueue ist eine unbegrenzte Warteschlange und kann jederzeit erweitert werden, daher ist der Handler gleichbedeutend mit einer ungültigen TaskThreadFactory tf = neue TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
 Executor = neuer ThreadPoolExecutor (getMinSpareThreads(), getMaxThreads(), 60, Zeiteinheit.SEKUNDEN, Taskwarteschlange, tf);
 taskqueue.setParent( (ThreadPoolExecutor) Executor);
 }

öffentliche int prestartAllCoreThreads() {
 Int. n = 0;
 während (addWorker(null, true))
  ++n;
 Rückkehr n;
 }

public void execute(Ausführbarer Befehl) {
 wenn (Befehl == null)
  wirf eine neue NullPointerException();
 
 int c = ctl.get();
 	// Ist die Anzahl der Worker kleiner als die Anzahl der Core-Threads? Nach der Initialisierung in Tomcat ist die erste Bedingung im Allgemeinen nicht erfüllt und addWorker wird nicht aufgerufen.
 wenn (workerCountOf(c) < corePoolSize) {
  wenn (addWorker(Befehl, wahr))
  zurückkehren;
  c = ctl.get();
 }
 	// workQueue.offer(command), füge die Aufgabe zur Warteschlange hinzu,
 wenn (isRunning(c) && workQueue.offer(Befehl)) {
  int erneut prüfen = ctl.get();
  wenn (!isRunning(erneut prüfen) und entfernen(Befehl))
  ablehnen (Befehl);
  sonst wenn (workerCountOf(recheck) == 0)
  addWorker(null, false);
 }
 sonst wenn (!addWorker(Befehl, false))
  ablehnen (Befehl);
 }

öffentliches boolesches Angebot(E e) {
 wenn (e == null) wirf eine neue NullPointerException();
 endgültige Anzahl von AtomicIntegern = this.count;
 wenn (Anzahl.get() == Kapazität)
 gibt false zurück;
 int c = -1;
 Knoten<E> Knoten = neuer Knoten<E>(e);
 endgültiges ReentrantLock putLock = this.putLock;
 setLock.lock();
 versuchen {
 if (count.get() < Kapazität) {
  enqueue(node); //Hier Aufgaben zur Warteschlange hinzufügen c = count.getAndIncrement();
  wenn (c + 1 < Kapazität)
  nichtVoll.signal();
 }
 Endlich
 setzeLock.unlock();
 }
 wenn (c == 0)
 signalNotEmpty();
 gibt c >= 0 zurück;
}

// Aufgaben zur Warteschlange hinzufügen/**
 * Verknüpft den Knoten am Ende der Warteschlange.
 *
 * @param node der Knoten
 */
private void enqueue(Node<E> node) {
 // behaupten putLock.isHeldByCurrentThread();
 // behaupten, last.next == null;
 letzte = letzte.nächste = Knoten; //Linklistenstruktur letzte.nächste = Knoten; letzte = Knoten
}

/** Delegiert die Hauptlaufschleife an den äußeren RunWorker */
 öffentliche Leere ausführen() {
  führeWorker aus (dies);
 }

final void runWorker(Arbeiter w) {
 : Thread wt = Thread.currentThread();
 Ausführbare Aufgabe = w.firstTask;
 w.firstTask = null;
 w.unlock(); // Unterbrechungen zulassen
 Boolescher Wert „abrupt abgeschlossen“ = true;
 versuchen {
  while (task != null || (task = getTask()) != null) { //Schleife um Aufgaben in der Warteschlange abzurufen w.lock(); // Sperren try {
   //Vorabverarbeitung vor der Ausführung beforeExecute(wt, task);
   //Die Aufgaben in der Warteschlange beginnen mit der Ausführung von task.run();
   // Nachbearbeitung ausführen afterExecute(task, thrown);
  Endlich
   Aufgabe = null;
   w.abgeschlosseneAufgaben++;
   w.unlock(); // Sperre aufheben}
  }
  abgeschlossenAbrupt = falsch;
 Endlich
  ProzessWorkerExit(w, abrupt abgeschlossen);
 }
 }

öffentliches boolesches Angebot(E e) {
 wenn (e == null) wirf eine neue NullPointerException();
 endgültige Anzahl von AtomicIntegern = this.count;
 wenn (Anzahl.get() == Kapazität)
  gibt false zurück;
 int c = -1;
 Knoten<E> Knoten = neuer Knoten<E>(e);
 endgültiges ReentrantLock putLock = this.putLock;
 putLock.lock(); //Sperren versuchen {
  if (count.get() < Kapazität) {
  in Warteschlange einreihen (Knoten);
  c = zählen.getAndIncrement();
  wenn (c + 1 < Kapazität)
   nichtVoll.signal();
  }
 Endlich
  putLock.unlock(); //Sperre aufheben}
 wenn (c == 0)
  signalNotEmpty();
 gibt c >= 0 zurück;
 }

private Ausführbare getTask() {
 boolean timedOut = false; // Ist beim letzten poll() eine Zeitüberschreitung aufgetreten?
		// ...weglassen für (;;) {
  versuchen {
  Ausführbar r = zeitgesteuert?
   workQueue.poll(keepAliveTime, Zeiteinheit.NANOSEKUNDEN):
   workQueue.take(); //Holen Sie sich eine Aufgabe in die Warteschlange, wenn (r != null)
   Rückkehr r;
  Zeitüberschreitung = wahr;
  } Fang (InterruptedException-Wiederholung) {
  timedOut = falsch;
  }
 }
 }
öffentliche E take() wirft InterruptedException {
 Ex;
 int c = -1;
 endgültige Anzahl von AtomicIntegern = this.count;
 letztes ReentrantLock takeLock = this.takeLock;
 takeLock.lockInterruptibly(); // Sperrversuch {
  während (Anzahl.get() == 0) {
  notEmpty.await(); //Wenn sich keine Aufgabe in der Warteschlange befindet, warten}
  x = aus der Warteschlange nehmen();
  c = zählen.getAndDecrement();
  wenn (c > 1)
  notEmpty.signal();
 Endlich
  takeLock.unlock(); // Sperre aufheben}
 wenn (c == Kapazität)
  signalNotFull();
 gebe x zurück;
 }

geschützter finaler boolean-Vergleich und SetState(int expect, int update) {
 // Siehe unten für die Einrichtung der Intrinsics, um dies zu unterstützen
 gibt unsafe.compareAndSwapInt(diesen, stateOffset, erwarten, aktualisieren) zurück;
 }

//Die entsprechende Java-Basisebene ist eigentlich die native Methode, die dem C++-Code entspricht/**
* Aktualisieren Sie die Java-Variable atomar auf <tt>x</tt>, wenn sie aktuell
* Halten <tt>erwartet</tt>.
* @return <tt>true</tt> bei Erfolg
*/
öffentliches final natives boolean compareAndSwapInt(Objekt o, langer Offset,
      int erwartet,
      int x);

// Einen blockierenden Thread hinzufügen private Node addConditionWaiter() {
  Knoten t = letzterWaiter;
  // Wenn lastWaiter abgebrochen wird, bereinigen.
  wenn (t != null und t.waitStatus != Node.CONDITION) {
  unlinkCancelledWaiters();
  t = letzterKellner;
  }
  Knoten Knoten = neuer Knoten (Thread.currentThread(), Knoten.BEDINGUNG);
  wenn (t == null)
  firstWaiter = Knoten;
  anders
  t.nextWaiter = Knoten;
  lastWaiter = node; //Setze den neu blockierten Thread an das Ende der verknüpften Liste return node;
 }

// Einen blockierten Thread herausnehmen public final void signal() {
  wenn (!isHeldExclusively())
  wirf eine neue IllegalMonitorStateException();
  Node first = firstWaiter; //Der erste blockierte Thread in der verknüpften Liste, wenn (first != null)
  macheSignal(zuerst);
 }

//Nachdem du es erhalten hast, aktiviere diesen Thread final boolean transferForSignal(Node node) {
  LockSupport.unpark(node.thread);
 gibt true zurück;
 }
öffentliche statische Leere unparken (Thread Thread) {
 wenn (Thread != null)
  UNSAFE.unpark(thread);
 }