How to get result of an Activity without waiting for ? In a event driven fashion

Question

Team, I have a doubt in calling activities in parallel.

I know that activities can be called parallelly using the Async.function.

For my use case, I wanted to call n no of activities in parallel after receiving results from all activities I wanted to go to the next state either it could another activity or a decision task.

But here it gives me a Promise object which similar to Future in java. If we write promise.get() to get a result but it is blocking the thread.

I need something similar to event-driven fashion without blocking the thread.

Hope you understand my question!!

Answer 1

You don't have to use .get().

In Promise, you can register a callback function to be invoked when the result is available or an error is returned.

You can use one of the below depends on what you need:

• thenApply
• handle
• thenCompose
• exceptionally

This style is similar to Java's CompletableFuture.

  /**
   * Returns Promise that contains a result of a function. The function is called with the value of
   * this Promise when it is ready. #completeExceptionally is propagated directly to the returned
   * Promise skipping the function.
   *
   * <p>Note that no blocking calls are allowed inside of the function.
   */
  <U> Promise<U> thenApply(Functions.Func1<? super V, ? extends U> fn);

  /**
   * Returns Promise that contains a result of a function. The function is called with the value of
   * this Promise or with an exception when it is completed. If the function throws a {@link
   * RuntimeException} it fails the resulting promise.
   *
   * <p>Note that no blocking calls are allowed inside of the function.
   */
  <U> Promise<U> handle(Functions.Func2<? super V, RuntimeException, ? extends U> fn);

  /**
   * Returns a new Promise that, when this promise completes normally, is executed with this promise
   * as the argument to the supplied function.
   *
   * @param fn the function returning a new Promise
   * @param <U> the type of the returned CompletionStage's result
   * @return the Promise that completes when fn returned Promise completes.
   */
  <U> Promise<U> thenCompose(Functions.Func1<? super V, ? extends Promise<U>> fn);

  /**
   * Returns a new Promise that, when this promise completes exceptionally, is executed with this
   * promise's exception as the argument to the supplied function. Otherwise, if this promise
   * completes normally, then the returned promise also completes normally with the same value.
   *
   * @param fn the function to use to compute the value of the returned CompletionPromise if this
   *     CompletionPromise completed exceptionally
   * @return the new Promise
   */
  Promise<V> exceptionally(Functions.Func1<Throwable, ? extends V> fn);

Answer 2

Adding to the great Long's answer.

You can use Promise.anyOf to wait on the completion of a single Promise from a collection in a blocking manner.