--- title: Async Method Invocation category: Concurrency language: es tag: - Reactive --- ## Propósito Asynchronous method invocation (invocación de método asincrónico) es un patrón con el que el hilo o subproceso de llamada no se bloquea mientras espera resultados. El patrón proporciona procesamiento en paralelo de múltiples tareas independientes y recupera los resultados a través de devoluciones de llamada (callbacks) o esperando hasta que termine el procedimiento. ## Explicación Ejemplo cotidiano > Lanzar cohetes espaciales es un negocio apasionante. El comandante de la misión da la orden de lanzamiento y > después de un tiempo indeterminado, el cohete se lanza con éxito o falla miserablemente. En otras palabras > La invocación del método asíncrono inicia el procedimiento y vuelve inmediatamente antes de que la tarea termine > Los resultados del procedimiento se devuelven a la llamada posteriormente (callback). Según Wikipedia > En la programación multiproceso, la invocación de método asíncrono (AMI), también conocida como > llamadas de método asíncrono o el patrón asíncrono es un patrón de diseño en el que el lugar de la llamada > no se bloquea mientras espera que termine el código llamado. En cambio, el hilo de llamada es > notificado cuando llega la respuesta. Sondear para obtener una respuesta es una opción no deseada. **Ejemplo programático** En este ejemplo, estamos lanzando cohetes espaciales y desplegando vehículos lunares. La aplicación demuestra lo que hace el patrón de invocación del método asíncrono. Las partes clave del patrón son `AsyncResult` que es un contenedor intermedio para un valor evaluado de forma asíncrona, `AsyncCallback` que se puede proporcionar para que se ejecute al finalizar la tarea y `AsyncExecutor` que gestiona la ejecución de las tareas asíncronas. ```java public interface AsyncResult { boolean isCompleted(); T getValue() throws ExecutionException; void await() throws InterruptedException; } ``` ```java public interface AsyncCallback { void onComplete(T value, Optional ex); } ``` ```java public interface AsyncExecutor { AsyncResult startProcess(Callable task); AsyncResult startProcess(Callable task, AsyncCallback callback); T endProcess(AsyncResult asyncResult) throws ExecutionException, InterruptedException; } ``` `ThreadAsyncExecutor` es una implementación de `AsyncExecutor`. Se destacan algunas de sus partes clave a continuación. ```java public class ThreadAsyncExecutor implements AsyncExecutor { @Override public AsyncResult startProcess(Callable task) { return startProcess(task, null); } @Override public AsyncResult startProcess(Callable task, AsyncCallback callback) { var result = new CompletableResult<>(callback); new Thread( () -> { try { result.setValue(task.call()); } catch (Exception ex) { result.setException(ex); } }, "executor-" + idx.incrementAndGet()) .start(); return result; } @Override public T endProcess(AsyncResult asyncResult) throws ExecutionException, InterruptedException { if (!asyncResult.isCompleted()) { asyncResult.await(); } return asyncResult.getValue(); } } ``` Ahora está todo preparado para lanzar algunos cohetes y así poder ver cómo funciona todo. ```java public static void main(String[] args) throws Exception { // construye un nuevo objeto executor que ejecutará tareas asíncronas var executor = new ThreadAsyncExecutor(); // inicia algunas tareas asíncronas con diferentes tiempos de procesamiento, las dos últimas con controladores de devolución de llamada final var asyncResult1 = executor.startProcess(lazyval(10, 500)); final var asyncResult2 = executor.startProcess(lazyval("test", 300)); final var asyncResult3 = executor.startProcess(lazyval(50L, 700)); final var asyncResult4 = executor.startProcess(lazyval(20, 400), callback("Desplegando el rover lunar")); final var asyncResult5 = executor.startProcess(lazyval("devolución de llamada callback", 600), callback("Desplegando el rover lunar")); // emula el procesamiento en el hilo o subproceso actual mientras las tareas asíncronas se ejecutan en sus propios hilos o subprocesos Subproceso.dormir(350); // Oye, estamos trabajando duro aquí log("El comandante de la misión está bebiendo café"); // espera a que se completen las tareas final var result1 = executor.endProcess(asyncResult1); final var result2 = executor.endProcess(asyncResult2); final var result3 = executor.endProcess(asyncResult3); asyncResult4.await(); asyncResult5.await(); // registra los resultados de las tareas, las devoluciones de las llamadas se registran inmediatamente cuando se completan log("Cohete espacial <" + resultado1 + "> ha completado su lanzamiento"); log("Cohete espacial <" + resultado2 + "> ha completado su lanzamiento"); log("Cohete espacial <" + result3 + "> ha completado su lanzamiento"); } ``` Aquí está la salida de la consola del programa. ```java 21:47:08.227 [executor-2] INFO com.iluwatar.async.method.invocation.App - Cohete espacial lanzado con éxito 21:47:08.269 [main] INFO com.iluwatar.async.method.invocation.App - El comandante de la misión está bebiendo café 21:47:08.318 [executor-4] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <20> lanzado con éxito 21:47:08.335 [executor-4] INFO com.iluwatar.async.method.invocation.App Desplegando el rover lunar <20> 21:47:08.414 [executor-1] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <10> lanzado con éxito 21:47:08.519 [executor-5] INFO com.iluwatar.async.method.invocation.App - Cohete espacial lanzado con éxito 21:47:08.519 [executor-5] INFO com.iluwatar.async.method.invocation.App - Implementando el vehículo lunar 21:47:08.616 [executor-3] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <50> lanzado con éxito 21:47:08.617 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento del cohete espacial <10> completado 21:47:08.617 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento de cohete espacial completado 21:47:08.618 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento del cohete espacial <50> completado ``` # Diagrama de clase ![texto alternativo](./etc/async-method-invocation.png "Invocación de método asíncrono") ## Aplicabilidad Utiliza el patrón de invocación del método asíncrono cuando * Tienes múltiples tareas independientes que pueden ejecutarse en paralelo * Necesitas mejorar el desempeño de un grupo de tareas secuenciales * Tienes una cantidad limitada de capacidad de procesamiento o tareas de ejecución prolongada y la llamada no debe esperar a que las tareas estén listas ## Ejemplos cotidianos * [FutureTask](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/FutureTask.html) * [CompletableFuture](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html) * [ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html) * [Patrón asíncrono basado en tareas](https://msdn.microsoft.com/en-us/library/hh873175.aspx)