Detaillierte Erklärung, wie Java ExecutorService verwendet, um eine große Anzahl von Threads synchron auszuführen (Bild)

In diesem Artikel wird hauptsächlich die Verwendung von ExecutorService durch Java zur synchronen Ausführung einer großen Anzahl von Threads vorgestellt. ExecutorService kann die Stabilität unserer großen Anzahl von Threads beim Betrieb kritischer Ressourcen aufrechterhalten.

Seit Java 1.5 gibt es auf der offiziellen Website eine Klasse wie Executor. Diese Klasse kann die Stabilität unserer großen Anzahl von Threads beim Betrieb kritischer Ressourcen aufrechterhalten.
Beginnen wir mit einem Code:

TestRunnable.java

public class TestRunnable implements Runnable {
  private String name;

  public TestRunnable(String name) {
    this.name = name;
  }

  @Override
  public void run() {
    while (true) {
      if (Main.Surplus < 0)
        return;
      Main.Surplus--;
      System.out.println(name + " " + Main.Surplus);
    }
  }
}

Haupteingang

public static void main(String[] args) {

     TestRunnable runnable = new TestRunnable("runnable1");
     TestRunnable runnable2 = new TestRunnable("runnable2");

     Thread t1 = new Thread(runnable);
     Thread t2 = new Thread(runnable2);

     t1.start();
     t2.start();

  }

In Auf diese Weise müssen wir, wie Sie sehen, die Daten durcheinander bringen. Natürlich können wir zu diesem Zeitpunkt ein synchronisiertes Schlüsselwort hinzufügen, aber es wird auch einige kleinere Probleme geben

Als nächstes werde ich einen in Java integrierten Thread-Verwaltungsmechanismus verwenden, um dieses Problem zu lösen. Die Idee zur Lösung dieses Problems besteht wahrscheinlich darin, dass wir einen Thread-Pool verwalten und alle in den Thread eintreten Pool, und wir öffnen nur einen Thread, wodurch Anforderungen nacheinander ausgeführt und kritische Ressourcen nacheinander aufgerufen werden können, was sehr sicher ist.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
  public static int Surplus = 10;

  private ExecutorService executor = Executors.newSingleThreadExecutor();

  void addTask(Runnable runnable) {
    executor.execute(runnable);
  }

  <V> V addTask(Callable<V> callable) {
    Future<V> submit = executor.submit(callable);
    try {
      return submit.get();
    } catch (InterruptedException e) {
      System.out.println("InterruptedException" + e.toString());
    } catch (ExecutionException e) {
      System.out.println("ExecutionException" + e.toString());
    }
    return null;
  }

  public void testAddTask(String name) {
    addTask(new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < 3; i++) {
          if (Main.Surplus <= 0)
            return;
          Main.Surplus--;
          System.out.println(name + " " + Main.Surplus);
        }

      }
    });
  }

  public void testAddTask2(String name) {
    int count = addTask(new Callable<Integer>() {
      @Override
      public Integer call() throws Exception {
        for (int i = 0; i < 3; i++) {
          if (Main.Surplus <= 0)
            return 0;
          Main.Surplus--;
          System.out.println(name + " " + Main.Surplus);
        }
        return Main.Surplus;
      }
    });

  }

  public void close() {
    executor.shutdown();
  }

  public static void main(String[] args) {
    Main main = new Main();
    main.testAddTask("task1");
    main.testAddTask2("task2");
    main.testAddTask("task3");
    main.testAddTask2("task4");
    main.close();
  }
}

Hier definieren wir zwei Methoden, addTask und addTask mit einem generischen Typ. Die Implementierungsprinzipien dieser beiden Methoden sind die gleichen. Für Rückrufe. es hängt von den Projektanforderungen ab.

Rufen Sie dann diese beiden Methoden auf, und Sie können sehen, dass das Ergebnis sehr geordnet und nicht chaotisch ist.

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung, wie Java ExecutorService verwendet, um eine große Anzahl von Threads synchron auszuführen (Bild). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!