IExecutor Schnittstelle

Definition

[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

Abgeleitet

Java.Util.Concurrent.AbstractExecutorService

Java.Util.Concurrent.IExecutorService

Java.Util.Concurrent.IScheduledExecutorService

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Attribute

RegisterAttribute

Implementiert

IJavaObject IJavaPeerable IDisposable

Hinweise

Ein Objekt, das gesendete Runnable Aufgaben ausführt. Diese Schnittstelle bietet eine Möglichkeit zum Entkoppeln der Aufgabenübermittlung von der Funktionsweise der einzelnen Aufgaben, einschließlich Details zur Threadverwendung, Planung usw. Eine Executor wird normalerweise verwendet, anstatt explizit Threads zu erstellen. Anstatt z. B. für jede Gruppe von Aufgaben zu aufrufen new Thread(new RunnableTask()).start() , können Sie Folgendes verwenden:

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

Die Schnittstelle erfordert jedoch nicht unbedingt, dass die Executor Ausführung asynchron ist. Im einfachsten Fall kann ein Executor die übermittelte Aufgabe sofort im Thread des Aufrufers ausführen:

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

In der Regel werden Aufgaben in einem anderen Thread als dem Thread des Aufrufers ausgeführt. Der folgende Executor führt einen neuen Thread für jede Aufgabe durch.

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

Viele Executor Implementierungen setzen eine Art von Einschränkung auf, wie und wann Vorgänge geplant werden. Der folgende Ausführungsausführer serialisiert die Übermittlung von Aufgaben an einen zweiten Executor, der einen zusammengesetzten Executor veranschaulicht.

{@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);
                }
              }
            }}

Die Executor in diesem Paket bereitgestellten Implementierungen implementieren ExecutorServiceeine umfangreichere Schnittstelle. Die ThreadPoolExecutor Klasse stellt eine erweiterbare Threadpoolimplementierung bereit. Die Executors Klasse stellt praktische Factorymethoden für diese Executors bereit.

Konsistenzeffekte im Speicher: Aktionen in einem Thread, bevor ein Runnable Objekt an ein Executor<i-Happen-Before></i> übermittelt wird, beginnt die Ausführung, vielleicht in einem anderen Thread.

Hinzugefügt in 1.5.

Java-Dokumentation für java.util.concurrent.Executor.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.