IExecutorService Interfaz

Definición

[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

Derivado

Java.Util.Concurrent.AbstractExecutorService

Java.Util.Concurrent.IScheduledExecutorService

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Atributos

RegisterAttribute

Implementaciones

IJavaObject IJavaPeerable IExecutor IDisposable

Comentarios

que Executor proporciona métodos para administrar la terminación y los métodos que pueden generar un para realizar un Future seguimiento del progreso de una o varias tareas asincrónicas.

Se ExecutorService puede apagar , lo que hará que rechace las nuevas tareas. Se proporcionan dos métodos diferentes para apagar un ExecutorService. El #shutdown método permitirá que las tareas enviadas anteriormente se ejecuten antes de finalizar, mientras que el #shutdownNow método impide que las tareas en espera se inicien e intenten detener la ejecución de tareas actualmente. Después de la finalización, un ejecutor no tiene tareas que se ejecuten activamente, ninguna tarea en espera de ejecución y no se puede enviar ninguna tarea nueva. Se debe apagar un no utilizados ExecutorService para permitir la recuperación de sus recursos.

El método submit amplía el método Executor#execute(Runnable) base mediante la creación y devolución de un Future objeto que se puede usar para cancelar la ejecución o esperar a que finalice. Los métodos invokeAny y invokeAll realizan las formas más útiles de ejecución masiva, ejecutando una colección de tareas y esperando al menos una o todas para completarse. (La clase ExecutorCompletionService se puede usar para escribir variantes personalizadas de estos métodos).

La Executors clase proporciona métodos de fábrica para los servicios executor proporcionados en este paquete.

<h2>Ejemplos< de uso/h2>

Este es un boceto de un servicio de red en el que los subprocesos de un grupo de subprocesos atenderán las solicitudes entrantes. Usa el método de fábrica preconfigurado 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
              }
            }}

ExecutorService También se puede establecer y cerrar (apagar, bloquear hasta finalizar) como se indica a continuación; ilustrando con un método de fábrica diferenteExecutors:

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

También es posible personalizar aún más. Por ejemplo, el método siguiente cierra una ExecutorService en dos fases, primero llamando shutdown a para rechazar las tareas entrantes y, a continuación, llamando shutdownNowa , si es necesario, para cancelar las tareas persistentes:

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

Efectos de coherencia de memoria: las acciones de un subproceso antes del envío de una tarea o Callable a una<ExecutorServiceRunnable tarea i>suceden antes< o i> de las acciones realizadas por esa tarea, que a su vez se producen antes de que el resultado se recupere a través Future.get()de .

Agregado en 1.5.

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

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.