Skip to content
Home » Using Awaitility to Wait for a Long-Running Execution to Complete

Using Awaitility to Wait for a Long-Running Execution to Complete

woman talking on the telephone

In modern software development, it’s common to encounter scenarios where a task or operation takes a significant amount of time to complete. Managing the synchronization and timing of such long-running executions can be challenging. Thankfully, Awaitility, a powerful Java library, provides an elegant solution. In this blog post, we will explore how Awaitility can be used to wait for a long-running execution to finish.

Understanding Awaitility

Awaitility is a Java library that simplifies waiting for asynchronous or long-running operations to complete. It offers a fluent and expressive API for defining conditions that must be met before proceeding with subsequent code execution. Whether you are waiting for a background task, a database query, or an external service response, Awaitility provides a convenient way to manage the timing and synchronization of such operations.

Example Scenario

Let’s dive into the example. In this scenario, we have a class called LongRunningTask that simulates a time-consuming operation. The corresponding test class, LongRunningTaskTest, demonstrates how Awaitility can be used to wait for the execution of this task to complete.

Using Awaitility

To begin using Awaitility, ensure you have added it as a dependency to your Maven or Gradle project. Once added, you can incorporate Awaitility into your test code.

First, import the necessary Awaitility classes:

import static org.awaitility.Awaitility.*;
import static org.hamcrest.Matchers.*;

Next, define a test method called testLongRunningTask() in the test class:

public void testLongRunningTask() {
    LongRunningTask task = new LongRunningTask();

    CompletableFuture<Void> executionFuture = CompletableFuture.runAsync(task::execute);

    assertThat(task.isFinished(), is(true));

Inside the test method, we instantiate the LongRunningTask class, representing our long-running execution. We then create a CompletableFuture by invoking runAsync() and passing a method reference to the execute() method of the task object.

The crucial part is await().until(executionFuture::isDone). This statement instructs Awaitility to wait until the executionFuture is marked as done, indicating that the task has completed. Awaitility continuously evaluates the condition specified, checking if the future is done. Once the condition is met, Awaitility proceeds with the execution of subsequent code.

Finally, we assert the result using assertThat() and the is() matcher, ensuring that the isFinished() method of the task object returns true, indicating that the execution has finished.


Awaitility simplifies the management of long-running executions by providing a fluent and expressive API for waiting until a specified condition is met. In the example we explored, Awaitility was used to wait for the completion of a long-running task. By incorporating Awaitility into your code, you can ensure reliable and synchronized execution of time-consuming operations.

Remember to explore the Awaitility documentation to discover additional features and advanced usage scenarios. With Awaitility, you can streamline the synchronization and timing of asynchronous or long-running operations, leading to more robust and efficient Java applications.

Start incorporating Awaitility into your projects and experience the benefits of simplified task synchronization.