IExecutor Interfaz

Definición

Espacio de nombres:: Java.Util.Concurrent

Ensamblado:: Mono.Android.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Objeto que ejecuta tareas enviadas Runnable .

[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

Derivado: Java.Util.Concurrent.AbstractExecutorService

Java.Util.Concurrent.IExecutorService

Java.Util.Concurrent.IScheduledExecutorService

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Atributos: RegisterAttribute

Implementaciones: IJavaObject IJavaPeerable IDisposable

Comentarios

Objeto que ejecuta tareas enviadas Runnable . Esta interfaz proporciona una manera de desacoplar el envío de tareas desde la mecánica de cómo se ejecutará cada tarea, incluidos los detalles del uso de subprocesos, la programación, etc. Executor Normalmente se usa en lugar de crear subprocesos explícitamente. Por ejemplo, en lugar de invocar new Thread(new RunnableTask()).start() para cada un conjunto de tareas, puede usar:

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

Sin embargo, la interfaz no requiere estrictamente que la Executor ejecución sea asincrónica. En el caso más sencillo, un ejecutor puede ejecutar la tarea enviada inmediatamente en el subproceso del autor de la llamada:

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

Normalmente, las tareas se ejecutan en algún subproceso distinto del subproceso del autor de la llamada. El ejecutor siguiente genera un nuevo subproceso para cada tarea.

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

Muchas Executor implementaciones imponen algún tipo de limitación sobre cómo y cuándo se programan las tareas. El ejecutor siguiente serializa el envío de tareas a un segundo ejecutor, que ilustra un ejecutor compuesto.

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

Las Executor implementaciones proporcionadas en este paquete implementan ExecutorService, que es una interfaz más extensa. La ThreadPoolExecutor clase proporciona una implementación extensible del grupo de subprocesos. La Executors clase proporciona métodos de fábrica convenientes para estos ejecutores.

Efectos de coherencia de memoria: las acciones de un subproceso antes de enviar un Runnable objeto a un Executor<I>happen-before</i> su ejecución comienza, quizás en otro subproceso.

Agregado en 1.5.

Java documentación para java.util.concurrent.Executor.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el proyecto de código abierto de Android y se usan según los términos descritos en la licencia de atribución de Creative Commons 2.5.

Propiedades

Nombre	Description
Handle	Obtiene el valor JNI del objeto Android subyacente. (Heredado de IJavaObject)
JniIdentityHashCode	Devuelve el valor de `java.lang.System.identityHashCode()` para la instancia ajustada. (Heredado de IJavaPeerable)
JniManagedPeerState	Estado del mismo nivel administrado. (Heredado de IJavaPeerable)
JniPeerMembers	Compatibilidad con la invocación y el acceso de miembros. (Heredado de IJavaPeerable)
PeerReference	Devuelve un JniObjectReference de la instancia de objeto Java ajustada. (Heredado de IJavaPeerable)

Métodos

Nombre	Description
Disposed()	Se llama cuando se ha eliminado la instancia. (Heredado de IJavaPeerable)
DisposeUnlessReferenced()	Si no hay referencias pendientes a esta instancia, llama a `Dispose()`; de lo contrario, no hace nada. (Heredado de IJavaPeerable)
Execute(IRunnable)	Ejecuta el comando especificado en algún momento en el futuro.
Finalized()	Se llama cuando se ha finalizado la instancia. (Heredado de IJavaPeerable)
SetJniIdentityHashCode(Int32)	Establezca el valor devuelto por `JniIdentityHashCode`. (Heredado de IJavaPeerable)
SetJniManagedPeerState(JniManagedPeerStates)	Objeto que ejecuta tareas enviadas `Runnable` . (Heredado de IJavaPeerable)
SetPeerReference(JniObjectReference)	Establezca el valor devuelto por `PeerReference`. (Heredado de IJavaPeerable)
UnregisterFromRuntime()	Anule el registro de esta instancia para que el entorno de ejecución no lo devuelva de invocaciones futuras Java.Interop.JniRuntime+JniValueManager.PeekValue . (Heredado de IJavaPeerable)

Métodos de extensión

Nombre	Description
GetJniTypeName(IJavaPeerable)	Obtiene el nombre JNI del tipo de la instancia `self`.
JavaAs<TResult>(IJavaPeerable)	Intente coerción `self` para escribir `TResult`, comprobando que la coerción es válida en el lado de Java.
JavaCast<TResult>(IJavaObject)	Realiza una conversión de tipos comprobados en tiempo de ejecución de Android.
JavaCast<TResult>(IJavaObject)	Objeto que ejecuta tareas enviadas `Runnable` .
TryJavaCast<TResult>(IJavaPeerable, TResult)	Intente coerción `self` para escribir `TResult`, comprobando que la coerción es válida en el lado de Java.

Se aplica a