ThreadPoolExecutor-Klasse

java.util.concurrent.ThreadPoolExecutor ist ein ExecutorService zum Ausführen jeder übermittelten Aufgabe mit einem von möglicherweise mehreren gepoolten Threads, die normalerweise mit den Factory-Methoden von Executors konfiguriert werden. Es bietet auch verschiedene Dienstprogrammmethoden, um aktuelle Thread-Statistiken zu überprüfen und zu steuern.

ThreadPoolExecutor-Methoden

Sr.Nr.	Methode & Beschreibung
1	protected void afterExecute(Runnable r, Throwable t) Methode, die nach Abschluss der Ausführung des angegebenen Runnable aufgerufen wird.
2	void allowCoreThreadTimeOut(boolean value) Legt die Richtlinie fest, die regelt, ob Core-Threads eine Zeitüberschreitung aufweisen und beendet werden können, wenn innerhalb der Keep-Alive-Zeit keine Aufgaben eintreffen. Sie wird bei Bedarf ersetzt, wenn neue Aufgaben eintreffen.
3	boolean allowsCoreThreadTimeOut() Gibt true zurück, wenn dieser Pool das Timeout von Core-Threads ermöglicht und beendet wird, wenn innerhalb der keepAlive-Zeit keine Aufgaben eintreffen, und wird bei Bedarf ersetzt, wenn neue Aufgaben eintreffen.
4	boolean awaitTermination(long timeout, TimeUnit unit) Blockiert, bis alle Aufgaben nach einer Anforderung zum Herunterfahren ausgeführt wurden oder das Zeitlimit auftritt oder der aktuelle Thread unterbrochen wird, je nachdem, was zuerst eintritt.
5	protected void beforeExecute(Thread t, Runnable r) Methode, die vor dem Ausführen der angegebenen Runnable im angegebenen Thread aufgerufen wird.
6	void execute(Runnable command) Führt die angegebene Aufgabe irgendwann in der Zukunft aus.
7	protected void finalize() Ruft das Herunterfahren auf, wenn auf diesen Executor nicht mehr verwiesen wird und keine Threads vorhanden sind.
8	int getActiveCount() Gibt die ungefähre Anzahl von Threads zurück, die aktiv Aufgaben ausführen.
9	long getCompletedTaskCount() Gibt die ungefähre Gesamtzahl der Aufgaben zurück, die die Ausführung abgeschlossen haben.
10	int getCorePoolSize() Gibt die Kernanzahl der Threads zurück.
11	long getKeepAliveTime(TimeUnit unit) Gibt die Keep-Alive-Zeit des Threads zurück. Dies ist die Zeit, die Threads, die die Größe des Kernpools überschreiten, möglicherweise inaktiv bleiben, bevor sie beendet werden.
12	int getLargestPoolSize() Gibt die größte Anzahl von Threads zurück, die jemals gleichzeitig im Pool waren.
13	int getMaximumPoolSize() Gibt die maximal zulässige Anzahl von Threads zurück.
14	int getPoolSize() Gibt die aktuelle Anzahl der Threads im Pool zurück.
15	BlockingQueue getQueue() Gibt die von diesem Executor verwendete Taskwarteschlange zurück.
15	RejectedExecutionHandler getRejectedExecutionHandler() Gibt den aktuellen Handler für nicht ausführbare Aufgaben zurück.
16	long getTaskCount() Gibt die ungefähre Gesamtzahl der Aufgaben zurück, deren Ausführung jemals geplant wurde.
17	ThreadFactory getThreadFactory() Gibt die Thread-Factory zurück, die zum Erstellen neuer Threads verwendet wurde.
18	boolean isShutdown() Gibt true zurück, wenn dieser Executor heruntergefahren wurde.
19	boolean isTerminated() Gibt true zurück, wenn alle Aufgaben nach dem Herunterfahren abgeschlossen wurden.
20	boolean isTerminating() Gibt true zurück, wenn dieser Executor gerade nach shutdown () oder shutdownNow () beendet wird, aber noch nicht vollständig beendet wurde.
21	int prestartAllCoreThreads() Startet alle Kernthreads, sodass sie untätig auf die Arbeit warten.
22	boolean prestartCoreThread() Startet einen Kernthread, wodurch er untätig auf die Arbeit wartet.
23	void purge() Versucht, alle abgebrochenen zukünftigen Aufgaben aus der Arbeitswarteschlange zu entfernen.
24	boolean remove(Runnable task) Entfernt diese Aufgabe aus der internen Warteschlange des Executors, wenn sie vorhanden ist, sodass sie nicht ausgeführt wird, wenn sie noch nicht gestartet wurde.
25	void setCorePoolSize(int corePoolSize) Legt die Kernanzahl der Threads fest.
26	void setKeepAliveTime(long time, TimeUnit unit) Legt das Zeitlimit fest, für das Threads möglicherweise inaktiv bleiben, bevor sie beendet werden.
27	void setMaximumPoolSize(int maximumPoolSize) Legt die maximal zulässige Anzahl von Threads fest.
28	void setRejectedExecutionHandler(RejectedExecutionHandler handler) Legt einen neuen Handler für nicht ausführbare Aufgaben fest.
29	void setThreadFactory(ThreadFactory threadFactory) Legt die Thread-Factory fest, die zum Erstellen neuer Threads verwendet wird.
30	void shutdown() Initiiert ein ordnungsgemäßes Herunterfahren, bei dem zuvor übermittelte Aufgaben ausgeführt werden, aber keine neuen Aufgaben akzeptiert werden.
31	List<Runnable> shutdownNow() Es wird versucht, alle aktiv ausgeführten Aufgaben zu stoppen, die Verarbeitung wartender Aufgaben anzuhalten und eine Liste der Aufgaben zurückzugeben, die auf die Ausführung gewartet haben.
32	protected void terminated() Methode, die aufgerufen wird, wenn der Executor beendet wurde.
33	String toString() Gibt eine Zeichenfolge zurück, die diesen Pool sowie seinen Status identifiziert, einschließlich Angaben zum Ausführungsstatus und zur geschätzten Anzahl von Arbeitern und Aufgaben.

Beispiel

Das folgende TestThread-Programm zeigt die Verwendung der ThreadPoolExecutor-Schnittstelle in einer threadbasierten Umgebung.

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

public class TestThread {
	
   public static void main(final String[] arguments) throws InterruptedException {
      ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();

      //Stats before tasks execution
      System.out.println("Largest executions: "
         + executor.getLargestPoolSize());
      System.out.println("Maximum allowed threads: "
         + executor.getMaximumPoolSize());
      System.out.println("Current threads in pool: "
         + executor.getPoolSize());
      System.out.println("Currently executing threads: "
         + executor.getActiveCount());
      System.out.println("Total number of threads(ever scheduled): "
         + executor.getTaskCount());

      executor.submit(new Task());
      executor.submit(new Task());

      //Stats after tasks execution
      System.out.println("Core threads: " + executor.getCorePoolSize());
      System.out.println("Largest executions: "
         + executor.getLargestPoolSize());
      System.out.println("Maximum allowed threads: "
         + executor.getMaximumPoolSize());
      System.out.println("Current threads in pool: "
         + executor.getPoolSize());
      System.out.println("Currently executing threads: "
         + executor.getActiveCount());
      System.out.println("Total number of threads(ever scheduled): "
         + executor.getTaskCount());

      executor.shutdown();
   }  

   static class Task implements Runnable {

      public void run() {

         try {
            Long duration = (long) (Math.random() * 5);
            System.out.println("Running Task! Thread Name: " +
               Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(duration);
            System.out.println("Task Completed! Thread Name: " +
               Thread.currentThread().getName());
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

Dies führt zu folgendem Ergebnis.

Ausgabe

Largest executions: 0
Maximum allowed threads: 2147483647
Current threads in pool: 0
Currently executing threads: 0
Total number of threads(ever scheduled): 0
Core threads: 0
Largest executions: 2
Maximum allowed threads: 2147483647
Current threads in pool: 2
Currently executing threads: 2
Total number of threads(ever scheduled): 2
Running Task! Thread Name: pool-1-thread-2
Running Task! Thread Name: pool-1-thread-1
Task Completed! Thread Name: pool-1-thread-1
Task Completed! Thread Name: pool-1-thread-2