Class AsyncInternal

java.lang.Object
io.temporal.internal.sync.AsyncInternal

public final class AsyncInternal extends Object
Contains support for asynchronous invocations. The basic idea is that any code is invoked in a separate WorkflowThread. Internally, it maps to a task executed by a thread pool, so there is not much overhead doing it if the operation doesn't block for a long time tying a physical thread. Async allows to have asynchronous implementation of synchronous interfaces. If a synchronous interface is invoked using execute(boolean, Functions.Func) then isAsync() going to return true and implementation can take non-blocking path and return Promise as a result using setAsyncResult(Promise). Then it can return any value from the sync method as it is going to be ignored.
  • Method Details

    • function

      public static <R> Promise<R> function(Functions.Func<R> function)
      Invokes zero argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      Returns:
      promise that contains function result or failure
    • function

      public static <A1, R> Promise<R> function(Functions.Func1<A1,R> function, A1 arg1)
      Invokes one argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      arg1 - first function argument
      Returns:
      promise that contains function result or failure
    • function

      public static <A1, A2, R> Promise<R> function(Functions.Func2<A1,A2,R> function, A1 arg1, A2 arg2)
      Invokes two argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      arg1 - first function argument
      arg2 - second function argument
      Returns:
      promise that contains function result or failure
    • function

      public static <A1, A2, A3, R> Promise<R> function(Functions.Func3<A1,A2,A3,R> function, A1 arg1, A2 arg2, A3 arg3)
      Invokes three argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      arg1 - first function argument
      arg2 - second function argument
      arg3 - third function argument
      Returns:
      promise that contains function result or failure
    • function

      public static <A1, A2, A3, A4, R> Promise<R> function(Functions.Func4<A1,A2,A3,A4,R> function, A1 arg1, A2 arg2, A3 arg3, A4 arg4)
      Invokes four argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      arg1 - first function argument
      arg2 - second function argument
      arg3 - third function argument
      arg4 - forth function argument
      Returns:
      promise that contains function result or failure
    • function

      public static <A1, A2, A3, A4, A5, R> Promise<R> function(Functions.Func5<A1,A2,A3,A4,A5,R> function, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
      Invokes five argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      arg1 - first function argument
      arg2 - second function argument
      arg3 - third function argument
      arg4 - forth function argument
      arg5 - fifth function argument
      Returns:
      promise that contains function result or failure
    • function

      public static <A1, A2, A3, A4, A5, A6, R> Promise<R> function(Functions.Func6<A1,A2,A3,A4,A5,A6,R> function, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
      Invokes six argument function asynchronously.
      Parameters:
      function - Function to execute asynchronously
      arg1 - first function argument
      arg2 - second function argument
      arg3 - third function argument
      arg4 - forth function argument
      arg5 - fifth function argument
      arg6 - sixth function argument
      Returns:
      promise that contains function result or failure
    • procedure

      public static Promise<Void> procedure(Functions.Proc procedure)
      Invokes zero argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      Returns:
      promise that contains procedure result or failure
    • procedure

      public static <A1> Promise<Void> procedure(Functions.Proc1<A1> procedure, A1 arg1)
      Invokes one argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      arg1 - first procedure argument
      Returns:
      promise that contains procedure result or failure
    • procedure

      public static <A1, A2> Promise<Void> procedure(Functions.Proc2<A1,A2> procedure, A1 arg1, A2 arg2)
      Invokes two argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      arg1 - first procedure argument
      arg2 - second procedure argument
      Returns:
      promise that contains procedure result or failure
    • procedure

      public static <A1, A2, A3> Promise<Void> procedure(Functions.Proc3<A1,A2,A3> procedure, A1 arg1, A2 arg2, A3 arg3)
      Invokes three argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      arg1 - first procedure argument
      arg2 - second procedure argument
      arg3 - third procedure argument
      Returns:
      promise that contains procedure result or failure
    • procedure

      public static <A1, A2, A3, A4> Promise<Void> procedure(Functions.Proc4<A1,A2,A3,A4> procedure, A1 arg1, A2 arg2, A3 arg3, A4 arg4)
      Invokes four argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      arg1 - first procedure argument
      arg2 - second procedure argument
      arg3 - third procedure argument
      arg4 - forth procedure argument
      Returns:
      promise that contains procedure result or failure
    • procedure

      public static <A1, A2, A3, A4, A5> Promise<Void> procedure(Functions.Proc5<A1,A2,A3,A4,A5> procedure, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
      Invokes five argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      arg1 - first procedure argument
      arg2 - second procedure argument
      arg3 - third procedure argument
      arg4 - forth procedure argument
      arg5 - fifth procedure argument
      Returns:
      promise that contains procedure result or failure
    • procedure

      public static <A1, A2, A3, A4, A5, A6> Promise<Void> procedure(Functions.Proc6<A1,A2,A3,A4,A5,A6> procedure, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
      Invokes six argument procedure asynchronously.
      Parameters:
      procedure - Procedure to execute asynchronously
      arg1 - first procedure argument
      arg2 - second procedure argument
      arg3 - third procedure argument
      arg4 - forth procedure argument
      arg5 - fifth procedure argument
      arg6 - sixth procedure argument
      Returns:
      promise that contains procedure result or failure
    • await

      public static Promise<Void> await(Supplier<Boolean> unblockCondition)
    • await

      public static Promise<Boolean> await(Duration timeout, Supplier<Boolean> unblockCondition)
    • retry

      public static <R> Promise<R> retry(RetryOptions options, Optional<Duration> expiration, Functions.Func<Promise<R>> fn)
    • isAsync

      public static boolean isAsync(Object func)
    • isAsync

      public static boolean isAsync()
    • setAsyncResult

      public static <R> void setAsyncResult(Promise<R> result)
    • closeAsyncInvocation

      public static void closeAsyncInvocation()
      Closes async invocation created through initAsyncInvocation()