IExecutorService Interface

Définition

[Android.Runtime.Register("java/util/concurrent/ExecutorService", "", "Java.Util.Concurrent.IExecutorServiceInvoker")]
public interface IExecutorService : IDisposable, Java.Interop.IJavaPeerable, Java.Util.Concurrent.IExecutor

[<Android.Runtime.Register("java/util/concurrent/ExecutorService", "", "Java.Util.Concurrent.IExecutorServiceInvoker")>]
type IExecutorService = interface
    interface IExecutor
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Dérivé

Java.Util.Concurrent.AbstractExecutorService

Java.Util.Concurrent.IScheduledExecutorService

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable IExecutor IDisposable

Remarques

Qui Executor fournit des méthodes pour gérer l’arrêt et les méthodes qui peuvent produire un Future pour le suivi de la progression d’une ou plusieurs tâches asynchrones.

Une ExecutorService opération peut être arrêtée, ce qui l’entraîne à rejeter de nouvelles tâches. Deux méthodes différentes sont fournies pour arrêter un ExecutorService. La #shutdown méthode permet aux tâches précédemment envoyées d’être exécutées avant la fin, tandis que la #shutdownNow méthode empêche l’attente des tâches de démarrer et de tenter d’arrêter les tâches en cours d’exécution. À l’arrêt, un exécuteur n’a aucune tâche en cours d’exécution, aucune tâche en attente d’exécution et aucune nouvelle tâche ne peut être envoyée. Un usage inutilisé ExecutorService doit être arrêté pour autoriser la récupération de ses ressources.

La méthode submit étend la méthode Executor#execute(Runnable) de base en créant et en retournant un Future qui peut être utilisé pour annuler l’exécution et/ou attendre la fin. Les méthodes invokeAny et invokeAll effectuent les formes les plus fréquemment utiles d’exécution en bloc, l’exécution d’une collection de tâches, puis l’attente d’au moins un, ou tout, pour se terminer. (La classe ExecutorCompletionService peut être utilisée pour écrire des variantes personnalisées de ces méthodes.)

La Executors classe fournit des méthodes de fabrique pour les services d’exécuteur fournis dans ce package.

<Exemples< d’utilisation h2>/h2>

Voici un croquis d’un service réseau dans lequel les threads d’un service de pool de threads sont des requêtes entrantes. Il utilise la méthode de fabrique préconfigurée Executors#newFixedThreadPool :

{@code
            class NetworkService implements Runnable {
              private final ServerSocket serverSocket;
              private final ExecutorService pool;

              public NetworkService(int port, int poolSize)
                  throws IOException {
                serverSocket = new ServerSocket(port);
                pool = Executors.newFixedThreadPool(poolSize);
              }

              public void run() { // run the service
                try {
                  for (;;) {
                    pool.execute(new Handler(serverSocket.accept()));
                  }
                } catch (IOException ex) {
                  pool.shutdown();
                }
              }
            }

            class Handler implements Runnable {
              private final Socket socket;
              Handler(Socket socket) { this.socket = socket; }
              public void run() {
                // read and service request on socket
              }
            }}

Un ExecutorService peut également être établi et fermé (arrêt, blocage jusqu’à l’arrêt) comme suit ; illustrant une autre Executors méthode d’usine :

{@code
            try (ExecutorService e =  Executors.newWorkStealingPool()) {
              // submit or execute many tasks with e ...
            }}

Une personnalisation supplémentaire est également possible. Par exemple, la méthode suivante arrête une ExecutorService phase en deux phases, tout d’abord en appelant shutdown pour rejeter les tâches entrantes, puis en appelant shutdownNow, si nécessaire, pour annuler les tâches persistantes :

{@code
            void shutdownAndAwaitTermination(ExecutorService pool) {
              pool.shutdown(); // Disable new tasks from being submitted
              try {
                // Wait a while for existing tasks to terminate
                if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                  pool.shutdownNow(); // Cancel currently executing tasks
                  // Wait a while for tasks to respond to being cancelled
                  if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                      System.err.println("Pool did not terminate");
                }
              } catch (InterruptedException ex) {
                // (Re-)Cancel if current thread also interrupted
                pool.shutdownNow();
                // Preserve interrupt status
                Thread.currentThread().interrupt();
              }
            }}

Effets de cohérence de la mémoire : actions dans un thread avant la soumission d’une ou Callable d’une Runnable tâche à un ExecutorService<i>happen-before</i> toutes les actions effectuées par cette tâche, qui à son tour se produisent avant que le résultat soit récupéré via Future.get().

Ajouté à la version 1.5.

Java documentation pour java.util.concurrent.ExecutorService.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.