When building resilient applications, you often need to perform multiple operations in parallel to improve performance and user experience. Restate provides durable concurrency primitives that allow you to run tasks concurrently while maintaining deterministic execution during replays.

​
When to use concurrent tasks

Use concurrent tasks when you need to:
  • Call multiple external services simultaneously (e.g., fetching data from different APIs)
  • Race multiple operations and use the first result (e.g., trying multiple LLM providers)
  • Implement timeouts by racing an operation against a timer
  • Perform batch operations where individual tasks can run in parallel

​
Key benefits

  • Deterministic replay: Restate logs the order of completion, ensuring consistent behavior during failures
  • Fault tolerance: If your handler fails, tasks that were already completed will be replayed with their results, while pending tasks will be retried

​
Parallelizing tasks

Start multiple durable operations concurrently by calling them without immediately awaiting: 
// Start operations concurrently using DurableFuture
var call1 = ctx.runAsync(UserData.class, () -> fetchUserData(123));
var call2 = ctx.runAsync(OrderHistory.class, () -> fetchOrderHistory(123));
var call3 = AnalyticsServiceClient.fromContext(ctx).calculateMetric(123);

// Now wait for results as needed
UserData user = call1.await();
OrderHistory orders = call2.await();
Integer metric = call3.await();
Check out the guide on parallelizing work.

​
Retrieving results

Restate provides several patterns for coordinating concurrent tasks. All patterns use DurableFuture combinators that log the order of completion, ensuring deterministic behavior during replays.

​
Wait for the first completion

Select creates a DurableFuture that returns on the first completed DurableFuture of the provided ones. The semantics are similar to CompleteableFuture.anyOf(), but the outcome is stored in the Restate journal to be deterministically replayable. 
boolean res = Select.<Boolean>select().or(a1).or(a2).or(a3).await();

​
Wait for all tasks to complete

Await all creates a DurableFuture that awaits for all the provided DurableFutures to resolve. The semantics are similar to CompleteableFuture.allOf(), but the outcome is stored in the Restate journal to be deterministically replayable. 
DurableFuture.all(a1, a2, a3).await();