Was sind die vier Methoden zur Thread-Pool-Erstellung?

Methoden: newCachedThreadPool erstellt einen zwischenspeicherbaren Thread-Pool, newFixedThreadPool erstellt einen Thread-Pool fester Länge, newScheduledThreadPool erstellt einen Thread-Pool fester Länge und newSingleThreadExecutor erstellt einen Thread-Pool mit einem Thread.

Vier Methoden zur Thread-Pool-Erstellung

Java stellt vier Thread-Pools über Executors bereit:

1. Verwenden Sie newCachedThreadPool

newCachedThreadPool, um einen zwischenspeicherbaren Thread-Pool zu erstellen die Die Länge des Thread-Pools übersteigt den Verarbeitungsbedarf. Inaktive Threads können flexibel recycelt werden. Wenn keine Möglichkeit zum Recycling besteht, werden neue Threads erstellt.

Die Merkmale dieser Art von Thread-Pool sind:

• Die Anzahl der erstellten Arbeitsthreads ist nahezu unbegrenzt (tatsächlich gibt es eine Begrenzung, die Anzahl ist ganzzahlig. MAX_VALUE), sodass Threads erstellt werden können flexibel zum Thread-Pool hinzugefügt werden.

• Wenn längere Zeit keine Aufgabe an den Thread-Pool übermittelt wird, das heißt, wenn der Arbeitsthread für die angegebene Zeit inaktiv ist (Standard ist 1 Minute), wird der Arbeitsthread automatisch beendet. Wenn Sie nach der Beendigung eine neue Aufgabe senden, erstellt der Thread-Pool einen Arbeitsthread neu.

• Bei der Verwendung von CachedThreadPool müssen Sie darauf achten, die Anzahl der Aufgaben zu kontrollieren. Andernfalls kann es aufgrund einer großen Anzahl gleichzeitig laufender Threads zu einer Lähmung des Systems kommen.

Der Beispielcode lautet wie folgt:

 package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
   public class ThreadPoolExecutorTest {
   public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
    try {
    Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

2. Verwenden Sie newFixedThreadPool

, um einen Thread-Pool mit einer angegebenen Anzahl von Arbeitsthreads zu erstellen. Immer wenn eine Aufgabe übermittelt wird, wird ein Arbeitsthread erstellt. Wenn die Anzahl der Arbeitsthreads die anfängliche maximale Anzahl des Thread-Pools erreicht, wird die übermittelte Aufgabe in der Poolwarteschlange gespeichert.

FixedThreadPool ist ein typischer und hervorragender Thread-Pool. Er bietet die Vorteile eines Thread-Pools, der die Programmeffizienz verbessert und Overhead beim Erstellen von Threads spart. Wenn der Thread-Pool jedoch inaktiv ist, dh wenn sich keine ausführbaren Aufgaben im Thread-Pool befinden, werden die Arbeitsthreads nicht freigegeben und es werden auch bestimmte Systemressourcen belegt.

Der Beispielcode lautet wie folgt:

 package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class ThreadPoolExecutorTest {
  public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
   for (int i = 0; i < 10; i++) {
    final int index = i;
    try {
     Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

Da die Thread-Pool-Größe 3 beträgt, schläft jede Aufgabe nach der Ausgabe des Index 2 Sekunden lang, sodass alle zwei Sekunden 3 Zahlen gedruckt werden.

Die Größe des Thread-Pools fester Länge wird am besten entsprechend den Systemressourcen wie Runtime.getRuntime().availableProcessors() festgelegt.

3. Verwenden Sie newSingleThreadExecutor

, um einen Single-Threaded-Executor zu erstellen, d Ausführung in angegebener Reihenfolge (FIFO, LIFO, Priorität). Wenn dieser Thread abnormal endet, wird er durch einen anderen ersetzt, um eine sequenzielle Ausführung sicherzustellen. Das größte Merkmal eines einzelnen Arbeitsthreads besteht darin, dass er sicherstellen kann, dass Aufgaben nacheinander ausgeführt werden und nicht mehrere Threads gleichzeitig aktiv sind.

Der Beispielcode lautet wie folgt:

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

4. Verwenden Sie newScheduledThreadPool

, um einen Thread-Pool mit fester Länge zu erstellen und die geplante und periodische Aufgabenausführung zu unterstützen.

Ausführung um 3 Sekunden verzögern. Der Beispielcode für die verzögerte Ausführung lautet wie folgt:

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

bedeutet, dass er alle 3 Sekunden nach einer Verzögerung von 1 Sekunde ausgeführt wird. Der Beispielcode für die reguläre Ausführung lautet wie folgt:

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

Für weitere Programmierung -bezogenes Wissen besuchen Sie bitte: Website zum Programmierenlernen! !

Das obige ist der detaillierte Inhalt vonWas sind die vier Methoden zur Thread-Pool-Erstellung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!