Beispielcodeanalyse für ein detailliertes Verständnis der Java ThreadPoolExecutor-Parameter

In diesem Artikel werden hauptsächlich relevante Informationen für ein detailliertes Verständnis der Parameter von Java ThreadPoolExecutor vorgestellt. Freunde, die diese benötigen, können sich auf

Detaillierte Informationen zu den Parametern von Java ThreadPoolExecutor beziehen

1. Verwenden Sie Executors, um einen Thread-Pool zu erstellen. Natürlich verwenden Executors auch andere Parameter als new ThreadPoolExecutor

1. newFixedThreadPool()

Erstellen Sie einen Thread-Pool mit einer festen Anzahl von Threads. Da LinkedBlockingQueue verwendet wird, ist MaximumPoolSize nutzlos. Wenn corePoolSize voll ist, wird es zur LinkedBlockingQueue

Warteschlange hinzugefügt. Immer wenn ein Thread die Ausführung abschließt, nehmen Sie einen Thread aus der LinkedBlockingQueue-Warteschlange. Dadurch wird also ein Thread-Pool mit fester Größe erstellt.

2.newSingleThreadPool()

 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);
  }

Erstellen Sie einen Thread-Pool mit einer Anzahl von Threads von 1. Da LinkedBlockingQueue verwendet wird, ist die maximale PoolSize nutzlos Der Wert 1 gibt die Anzahl der Threads an. Wenn er voll ist, wird er in die Warteschlange gestellt. Wenn die Ausführung abgeschlossen ist, wird einer aus der Warteschlange genommen.

3.newCachedThreadPool()

 public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
      (new ThreadPoolExecutor(1, 1,
                  0L, TimeUnit.MILLISECONDS,
                  new LinkedBlockingQueue<Runnable>()));
  }

Erstellen Sie einen pufferbaren Thread-Pool. Keine Größenbeschränkung. Da die corePoolSize 0 ist, wird die Aufgabe in die SynchronousQueue-Warteschlange gestellt. SynchronousQueue kann nur eine Größe von 1 speichern, sodass sofort ein neuer Thread gestartet wird. Da die maximale PoolSize Integer.MAX_VALUE ist, kann die Größe als 2147483647 angesehen werden . Begrenzt durch die Speichergröße.

2. Verwenden Sie ThreadPoolExecutor, um einen Thread-Pool zu erstellen

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                   60L, TimeUnit.SECONDS,
                   new SynchronousQueue<Runnable>());
  }
public ThreadPoolExecutor(int corePoolSize,
             int maximumPoolSize,
             long keepAliveTime,
             TimeUnit unit,
             BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
       Executors.defaultThreadFactory(), defaultHandler);
  }

ThreadPoolExecutors

-Konstruktor

Parameter: 1. corePoolSize Die Anzahl der Threads

 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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
  }

2. MaximumPoolSize Die maximale Anzahl der Threads = corePoolSize, Threads werden erstellt. Runnable in workQueue einfügen

3. keepAliveTime behält die Überlebenszeit bei, wenn die Anzahl der Threads größer als corePoolSize ist, die maximale Zeit, die ein inaktiver Thread aufrechterhalten kann.

4. Zeiteinheit

5. workQueue enthält die blockierende Warteschlange von Aufgaben

6. threadFactory erstellt eine Thread-Factory

7. Handler-Ablehnungsstrategie

Aufgabenausführungssequenz:

1. Wenn die Anzahl der Threads kleiner als corePoolSize ist, erstellen Sie einen Thread zum Ausführen der Aufgabe.

2. Wenn die Anzahl der Threads größer oder gleich corePoolSize ist und die workQueue nicht voll ist, legen Sie sie in die workQueue

3. Die Anzahl der Threads ist größer oder gleich corePoolSize und wenn die workQueue voll ist, wird eine neue Aufgabe erstellt und ein Thread ausgeführt. Die Gesamtzahl sollte kleiner sein als MaximumPoolSize

4. Wenn die Gesamtzahl der Threads gleich MaximumPoolSize und WorkQueue ist voll ist, wird die „rejectedExecution“ des Handlers ausgeführt. Das ist die Ablehnungsstrategie.

ThreadPoolExecutor verfügt standardmäßig über vier Ablehnungsrichtlinien:

1. ThreadPoolExecutor.AbortPolicy() löst direkt

eine Ausnahme RejectedExecutionException

aus 2. ThreadPoolExecutor.CallerRunsPolicy() Rufen Sie die Ausführungsmethode direkt auf und blockieren Sie die Ausführung

3. ThreadPoolExecutor.DiscardPolicy() Nachfolgende Aufgaben direkt verwerfen

4. ThreadPoolExecutor.DiscardOldestPolicy() Anführer der Warteschlange verwerfen Natürlich kann die Aufgabe

RejectedExecutionHandler erben, um die Ablehnungsstrategie

zu schreiben

Das obige ist der detaillierte Inhalt vonBeispielcodeanalyse für ein detailliertes Verständnis der Java ThreadPoolExecutor-Parameter. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!