Explication détaillée de la façon dont Java utilise ExecutorService pour exécuter un grand nombre de threads de manière synchrone (image)

Cet article présente principalement l'utilisation par Java d'ExecutorService pour exécuter de manière synchrone un grand nombre de threads. ExecutorService peut maintenir la stabilité de notre grand nombre de threads lors de l'exploitation de ressources critiques.

Depuis Java 1.5, le site officiel a lancé une classe comme Executor. Cette classe peut maintenir la stabilité de notre grand nombre de threads lors de l'exploitation de ressources critiques.
Commençons par un morceau de 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);
    }
  }
}

entrée principale

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

  }

Dans de cette façon, comme vous pouvez le voir, les données doivent être gâchées. Bien sûr, nous pouvons ajouter un mot-clé synchronisé à ce moment-là, mais il y aura aussi quelques problèmes mineurs

<. 🎜> Ensuite, je le ferai Nous prévoyons d'utiliser un mécanisme de gestion de threads intégré à Java pour résoudre ce problème. L'idée pour résoudre ce problème est probablement que nous maintenons un pool de threads Lorsqu'il y a une demande d'opération, ils entrent tous dans le pool de threads. pool de threads, et nous n'ouvrons qu'un seul thread. , ce qui permet d'exécuter les requêtes de manière séquentielle et d'appeler les ressources critiques de manière séquentielle, ce qui est très

sûr.

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

Ici, nous définissons deux méthodes, addTask et addTask avec un type générique. Les principes d'implémentation de ces deux méthodes sont les mêmes. L'une d'elles a un rappel et l'autre pas. cela dépend des

exigences du projet.

Appelez ensuite ces deux méthodes respectivement, et vous pouvez voir que le résultat est très ordonné et non chaotique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!