Beispielcode-Analyse gleichzeitiger Aufrufe von ThreadPoolExecutor in Java

In diesem Artikel werden hauptsächlich relevante Informationen zur detaillierten Erklärung der gleichzeitigen Aufrufinstanz von Java ThreadPoolExecutor vorgestellt. Freunde, die sie benötigen, können darauf zurückgreifen

Die detaillierte Erklärung der gleichzeitigen Aufrufinstanz von Java ThreadPoolExecutor

Übersicht

Um die Verarbeitungsgeschwindigkeit von Aufgaben zu verbessern, werden normalerweise einige Parallelitätsmodelle verwendet Alle in ThreadPoolExecutor ist eins.

Der Code

package test.current;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class TestCallable {

  public static void main(String[] args) throws InterruptedException, ExecutionException {

    List<Callable<List<Long>>> tasks = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      Callable<List<Long>> task = new Callable<List<Long>>() {
        @Override
        public List<Long> call() throws Exception {
          return Arrays.asList(1L,2L);
        }
      };

      tasks.add(task);
    }

    List<Long> finalResults = new ArrayList<>(10);
    List<Future<List<Long>>> results = ThreadPool.getThreadPool().invokeAll(tasks);
    for(Future<List<Long>> ele : results) {
      List<Long> list = ele.get();
      finalResults.addAll(list);
    }

    System.out.println(finalResults);
  }
}

package test.current;

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

public class ThreadPool {
  private static final int CORE_SIZE = 8;

  private static final int MAX_SIZE = 12;

  private static final long KEEP_ALIVE_TIME = 30;

  private static final int QUEUE_SIZE = 50000;

  private static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_SIZE, MAX_SIZE, KEEP_ALIVE_TIME,
      TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(QUEUE_SIZE), new ThreadPoolExecutor.AbortPolicy());

  public static ThreadPoolExecutor getThreadPool() {
    return threadPool;
  }
}

kann eine aufrufbare Aufgabe für die Aufgaben erstellen, die ausgeführt werden müssen, und die Threads im Thread-Pool zur Ausführung verwenden Diese Aufgaben können gleichzeitig ausgeführt werden, wodurch die Effizienz der Aufgabenausführung verbessert wird.

Das obige ist der detaillierte Inhalt vonBeispielcode-Analyse gleichzeitiger Aufrufe von ThreadPoolExecutor in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!