IExecutor Interface

Définition

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

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

Dérivé

Java.Util.Concurrent.AbstractExecutorService

Java.Util.Concurrent.IExecutorService

Java.Util.Concurrent.IScheduledExecutorService

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable IDisposable

Remarques

Objet qui exécute des tâches envoyées Runnable . Cette interface permet de découpler la soumission de tâches à partir de la mécanique de l’exécution de chaque tâche, y compris les détails de l’utilisation du thread, de la planification, etc. Il Executor est normalement utilisé au lieu de créer explicitement des threads. Par exemple, au lieu d’appeler new Thread(new RunnableTask()).start() chacun d’un ensemble de tâches, vous pouvez utiliser :

{@code
            Executor executor = anExecutor();
            executor.execute(new RunnableTask1());
            executor.execute(new RunnableTask2());
            ...}

Toutefois, l’interface ne nécessite pas strictement que l’exécution Executor soit asynchrone. Dans le cas le plus simple, un exécuteur peut exécuter la tâche envoyée immédiatement dans le thread de l’appelant :

{@code
            class DirectExecutor implements Executor {
              public void execute(Runnable r) {
                r.run();
              }
            }}

Plus généralement, les tâches sont exécutées dans un thread autre que le thread de l’appelant. L’exécuteur ci-dessous génère un nouveau thread pour chaque tâche.

{@code
            class ThreadPerTaskExecutor implements Executor {
              public void execute(Runnable r) {
                new Thread(r).start();
              }
            }}

De nombreuses Executor implémentations imposent une certaine limitation quant à la façon et au moment où les tâches sont planifiées. L’exécuteur ci-dessous sérialise la soumission de tâches à un deuxième exécuteur, illustrant un exécuteur composite.

{@code
            class SerialExecutor implements Executor {
              final Queue<Runnable> tasks = new ArrayDeque<>();
              final Executor executor;
              Runnable active;

              SerialExecutor(Executor executor) {
                this.executor = executor;
              }

              public synchronized void execute(Runnable r) {
                tasks.add(() -> {
                  try {
                    r.run();
                  } finally {
                    scheduleNext();
                  }
                });
                if (active == null) {
                  scheduleNext();
                }
              }

              protected synchronized void scheduleNext() {
                if ((active = tasks.poll()) != null) {
                  executor.execute(active);
                }
              }
            }}

Les Executor implémentations fournies dans ce package implémentent ExecutorService, qui est une interface plus étendue. La ThreadPoolExecutor classe fournit une implémentation de pool de threads extensible. La Executors classe fournit des méthodes de fabrique pratiques pour ces exécuteurs.

Effets de cohérence de la mémoire : actions dans un thread avant de soumettre un Runnable objet à un Executor<i>happen-before</i> son exécution commence, peut-être dans un autre thread.

Ajouté à la version 1.5.

Java documentation pour java.util.concurrent.Executor.

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.