How to achieve async/await functionality in Java?

General Discussions
, ,
1

How can I achieve async/await functionality in Java?

As a C# developer who occasionally works with Java, I’m wondering if there is a Java async await equivalent. In simple terms, how can I replicate the following C# code in Java?

async Task<int> AccessTheWebAsync()
{ 
    HttpClient client = new HttpClient();
    var urlContents = await client.GetStringAsync("http://msdn.microsoft.com");
    return urlContents.Length;
}
2

Ah, when it comes to achieving async/await functionality in Java, it’s not as straightforward as it is in C#, but don’t worry! From my experience, we can still replicate this behavior using CompletableFuture in Java. Here’s an example to get you started with java async await functionality:

import java.net.http.*;
import java.net.URI;
import java.util.concurrent.*;

public class AsyncExample {
    public static CompletableFuture<Integer> accessTheWebAsync() {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://msdn.microsoft.com"))
                .build();

        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenApply(String::length);
    }

    public static void main(String[] args) {
        accessTheWebAsync().thenAccept(length -> 
            System.out.println("Downloaded content length: " + length)
        ).join();
    }
}

:white_check_mark: Pros:

  • Non-blocking approach.
  • Works great with modern Java HTTP clients.
  • Chainable with .thenApply(), .thenAccept(), etc.

This method closely mimics the behavior of async/await, making it much easier to work with asynchronous code in Java. If you are working with Java 8 or later, this is your go-to method for java async await functionality.

3

Good point, @babitakumari I totally agree with that approach, but here’s a little extra for those who might still be working with older Java versions (pre-Java 8) or prefer a bit more manual control. You can leverage ExecutorService for async tasks, giving you a bit more flexibility in managing threads and the flow of tasks. It’s still an effective way to simulate java async await behavior in earlier versions.

Check out this example:

import java.net.*;
import java.io.*;
import java.util.concurrent.*;

public class AsyncExample {
    public static Future<Integer> accessTheWebAsync(ExecutorService executor) {
        return executor.submit(() -> {
            URL url = new URL("http://msdn.microsoft.com");
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line);
            }
            return content.length();
        });
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = accessTheWebAsync(executor);
        System.out.println("Downloaded content length: " + future.get()); // Blocks until result is ready
        executor.shutdown();
    }
}

:white_check_mark: Pros:

  • Works with older Java versions.
  • Provides granular control over thread management.

:x: Cons:

  • The call to future.get() is blocking, which could impact performance.
  • Requires managing thread pools manually.

It’s still a solid method for achieving java async await if you want full control over how your threads are managed."

4

Great additions, guys! But here’s where things get super interesting – Java is evolving! With the introduction of Project Loom in Java 21+, we’re now looking at a much cleaner way to handle async tasks. It’s like Java’s version of async/await, but even simpler! Virtual threads allow us to write async code almost as if it’s synchronous – no more complex thread management or chained CompletableFuture calls.

Here’s how easy it can be with virtual threads in Java:

public static void main(String[] args) throws Exception {
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        Future<Integer> future = executor.submit(() -> {
            var client = HttpClient.newHttpClient();
            var request = HttpRequest.newBuilder()
                .uri(URI.create("http://msdn.microsoft.com"))
                .build();
            var response = client.send(request, HttpResponse.BodyHandlers.ofString());
            return response.body().length();
        });

        System.out.println("Downloaded content length: " + future.get()); // No thread pool blocking!
    }
}

:white_check_mark: Pros:

  • Virtual threads are lightweight, and thousands can run concurrently without issues.
  • More readable and simpler than CompletableFuture chains.
  • No need for manual thread pool management – Java takes care of it for you.

This is truly the future of java async await and will make handling asynchronous code in Java as easy as pie!"

5

Hey Java people. Behold the beautificity and simplicity of the C# implementation with async/await (which is equivalent to how you would do it in Node which is my weapon of choice)

Then contrast it with the horrific wall of text that is the Java implementations. Who the f needs builders for a fricking http request? And chaining of thenApply jada jada. And explicit typing everywhere when it is implicitly obvious what the types are.

Horrific. I worked with Java for decades and am so f-ing happy I got out of it. Never again