In recent years, asynchronous programming has become an essential paradigm to write efficient and responsive applications. In the .NET world, C# has the async and await keywords, which have significantly simplified the process of writing asynchronous code. These keywords allow developers to write code that performs asynchronous operations while maintaining a synchronous and readable structure.

Java, while not originally designed with the same straightforward async constructs as C#, has various ways of implementing asynchronous programming. This article explores how Java developers can achieve the functionality provided by C#'s async/await.

Understanding C# async and await

Before delving into Java equivalences, it's crucial to understand how C#'s async and await work. The main purpose of these keywords is to enable asynchronous operation without blocking the executing thread, making the application more responsive.

C# Example:

1public async Task<string> GetDataAsync()
2{
3    HttpClient client = new HttpClient();
4    HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");
5    string content = await response.Content.ReadAsStringAsync();
6    return content;
7}

In this example, GetDataAsync is marked as async and returns a Task<string>. The await keyword tells the compiler to asynchronously wait for the GetAsync and ReadAsStringAsync methods to complete without blocking the calling thread.

Asynchronous Programming in Java

Java does not have direct equivalents of async/await. However, Java can achieve similar behavior using various constructs and libraries that support asynchronous programming. Some popular options include using CompletableFuture, Java's concurrency framework, or third-party libraries like CompletableRx, Project Loom (an incubator project for virtual threads), and Reactive Streams.

Using CompletableFuture

Java 8 introduced CompletableFuture, a flexible and powerful way to achieve asynchronous programming that can capture much of the async/await experience.

Java Example:

1import java.util.concurrent.CompletableFuture;
2import java.util.concurrent.ExecutionException;
3
4public class AsyncExample {
5    public CompletableFuture<String> getDataAsync() {
6        return CompletableFuture.supplyAsync(() -> {
7            // Simulate HTTP request
8            try {
9                Thread.sleep(2000); // Simulating delay
10            } catch (InterruptedException e) {
11                e.printStackTrace();
12            }
13            return "Data from async operation";
14        });
15    }
16
17    public static void main(String[] args) {
18        AsyncExample example = new AsyncExample();
19        CompletableFuture<String> dataFuture = example.getDataAsync();
20
21        dataFuture.thenAccept(data -> {
22            System.out.println("Received data: " + data);
23        });
24
25        try {
26            // Block to keep the main thread alive for the async operation to complete
27            dataFuture.get();
28        } catch (InterruptedException | ExecutionException e) {
29            e.printStackTrace();
30        }
31    }
32}

In this Java example using CompletableFuture, supplyAsync is used to execute an asynchronous operation. The thenAccept method processes the result once available. Note the use of get() at the end to block the main thread until the completion of the task, which is often necessary to prevent premature application exit.

Java 21: Virtual Threads (Project Loom)

Java 21 introduces virtual threads as part of Project Loom to simplify concurrent and asynchronous programming.

Java Example with Virtual Threads:

1import java.util.concurrent.Executors;
2
3public class VirtualThreadsExample {
4    public static void main(String[] args) throws Exception {
5        var executor = Executors.newVirtualThreadPerTaskExecutor();
6        executor.submit(() -> {
7            try {
8                Thread.sleep(1000);
9                System.out.println("Virtual thread says hello!");
10            } catch (InterruptedException e) {
11                e.printStackTrace();
12            }
13        });
14
15        executor.shutdown(); // Properly shutdown the executor when done
16    }
17}

Virtual threads allow developers to write thread-based code that is efficient and scalable without the complexities that usually accompany traditional threads.

Comparison Table

Here's a table summarizing some key points of comparison and differences between C#'s async/await and Java's asynchronous techniques:

Conclusion

While Java does not have a built-in async/await mechanism akin to C#, it offers various ways to perform asynchronous programming. The use of CompletableFuture and the introduction of virtual threads simplify async code, making Java a competitive option for modern asynchronous programming needs. As Java continues to evolve, developers have more tools at their disposal to write clean and efficient asynchronous code.