com.ea.async

Class Async

java.lang.Object

com.ea.async.Async

public class Async
extends Object

This class together with bytecode instrumentation implements the async-await functionality in the JVM.

To use it call Async.await(future) from within methods whose return type is CompletionStage, CompletableFuture or subclasses of CompletableFuture.

Async.await(future) won't block. It is semantically equivalent to call future.join() But instead of blocking the code in instrumented to become a state machine that evolves as the futures passed to await are completed.

This is equivalent to use CompletableFuture composition methods (ex: thenApply, handle, thenCompose). The advantage of using await is that the code will resemble sequential blocking code.

Example:

 import static com.ea.async.Async.await;
 import static java.util.concurrent.CompletableFuture.completedFuture;*

 public class Store
 {
     public CompletableFuture buyItem(String itemTypeId, int cost)
     {
         if(!await(bank.decrement(cost))) {
             return completedFuture(false);
         }
         await(inventory.giveItem(itemTypeId));
         return completedFuture(true);
     }
 }
 

Constructor Summary

Constructors

Constructor and Description
Async()

Method Summary

Modifier and Type	Method and Description
static <T,F extends CompletionStage<T>> T	await(F future) This method will behave as a CompletableFuture.join() but will actually cause the caller to return a promise instead of blocking.
static void	init() Ensure that if no pre instrumentation was done, that the Async runtime instrumentation is running.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Async

public Async()

Method Detail

init

public static void init()

Ensure that if no pre instrumentation was done, that the Async runtime instrumentation is running.

Attention! The build time instrumentation will remove calls to this method.

await

public static <T,F extends CompletionStage<T>> T await(F future)

This method will behave as a CompletableFuture.join() but will actually cause the caller to return a promise instead of blocking. Calls to this method are replaced by the EA Async instrumentation.

Type Parameters:

T - the future value type.

Parameters:

future - a future to wait for.

Returns:

the return value of the future

Throws:

CompletionException - wrapping the actual exception if an exception occured.