When using the Java 11 HttpClient in a multithreaded environment, you need to ensure it is used in a thread-safe and efficient manner. Thankfully, the HttpClient introduced in Java 11 is designed to be thread-safe and can be shared among multiple threads without additional synchronization.

Here are the important points about using HttpClient in a multithreaded environment:

1. Create a Single HttpClient Instance

• HttpClient is thread-safe, so create a single shared instance of HttpClient and reuse it across your application. Do not create a new instance of HttpClient for every request, as it can lead to performance inefficiencies.
• Use the factory method HttpClient.newHttpClient() to create a default instance, or configure it with a custom builder.

Example:

package org.kodejava.net.http;

import java.net.http.HttpClient;
import java.time.Duration;

public class HttpClientBuilder {
    // Create a shared instance of HttpClient
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2) // Support HTTP/2
            .connectTimeout(Duration.ofSeconds(10)) // Set up a timeout
            .build();

    public static HttpClient getHttpClient() {
        return httpClient;
    }
}

2. Use Thread-Safe Methods

• Use the methods send() (for synchronous requests) or sendAsync() (for asynchronous requests) provided by HttpClient. These methods are thread-safe and can be invoked concurrently by multiple threads.
• You should handle response callbacks correctly in the case of asynchronous usage since they will be executed by the internal thread pool.

Synchronous Request Example:

package org.kodejava.net.http;

import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class SynchronousRequest {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("https://jsonplaceholder.typicode.com/posts"))
                .GET()
                .build();

        // Using the shared HttpClient instance
        HttpResponse<String> response = HttpClientBuilder.getHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Response code: " + response.statusCode());
        System.out.println("Response body: " + response.body());
    }
}

Asynchronous Request Example:

package org.kodejava.net.http;

import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.concurrent.CompletableFuture;

public class AsynchronousRequest {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts"))
                .GET()
                .build();

        // Asynchronous call
        CompletableFuture<HttpResponse<String>> futureResponse =
                HttpClientBuilder.getHttpClient()
                        .sendAsync(request, HttpResponse.BodyHandlers.ofString());

        // Handle response when it is ready
        futureResponse.thenAccept(response -> {
            System.out.println("Response code: " + response.statusCode());
            System.out.println("Response body: " + response.body());
        }).join(); // Wait for the response to complete
    }
}

3. Internal Thread Pool

• By default, the HttpClient uses an internal thread pool managed by a ForkJoinPool for asynchronous requests. You can customize this by providing your own Executor when configuring the HttpClient with the builder.

Example: Custom Executor

package org.kodejava.net.http;

import java.net.http.HttpClient;
import java.util.concurrent.Executors;

public class CustomExecutorExample {
    public static void main(String[] args) {
        HttpClient httpClient = HttpClient.newBuilder()
                .executor(Executors.newFixedThreadPool(10))
                .build();

        // Use this HttpClient instance for requests
    }
}

4. Timeouts

• Set a connection timeout at the HttpClient level using the connectTimeout method.
• For individual requests, you can specify a request timeout.

Example:

package org.kodejava.net.http;

import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;

public class RequestWithTimeout {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("https://jsonplaceholder.typicode.com/posts"))
                .timeout(Duration.ofSeconds(5)) // Set request-specific timeout
                .GET()
                .build();

        HttpResponse<String> response = HttpClientBuilder.getHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response body: " + response.body());
    }
}

5. Handle Exceptions

• Handle exceptions like timeouts, ConnectException, or server errors gracefully when making HTTP calls.
• Use try-catch blocks for synchronous methods and handle() or exceptionally() for asynchronous methods.

Example:

package org.kodejava.net.http;

import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.concurrent.CompletableFuture;

public class HandleExceptionsExample {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://invalid.url"))
                .GET()
                .build();

        CompletableFuture<HttpResponse<String>> futureResponse = HttpClientBuilder.getHttpClient()
                .sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .exceptionally(e -> {
                    System.out.println("Request failed: " + e.getMessage());
                    return null;
                });

        futureResponse.thenAccept(response -> {
            if (response != null) {
                System.out.println("Response code: " + response.statusCode());
            }
        }).join();
    }
}

6. Handling Concurrency

• In multithreaded scenarios, the HttpClient can process concurrent requests efficiently since it is non-blocking, especially when using sendAsync(), and does not require manual synchronization.
• You can run multiple requests in parallel by delegating each request to a thread or submitting tasks to an ExecutorService.

Example: Multiple Requests in Parallel

package org.kodejava.net.http;

import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class ParallelRequestsExample {
    public static void main(String[] args) {
        List<URI> uris = List.of(
                URI.create("https://jsonplaceholder.typicode.com/posts/1"),
                URI.create("https://jsonplaceholder.typicode.com/posts/2"),
                URI.create("https://jsonplaceholder.typicode.com/posts/3")
        );

        List<CompletableFuture<Void>> futures = uris.stream()
                .map(uri -> {
                    HttpRequest request = HttpRequest.newBuilder().uri(uri).GET().build();
                    return HttpClientBuilder.getHttpClient()
                            .sendAsync(request, HttpResponse.BodyHandlers.ofString())
                            .thenAccept(response -> {
                                System.out.println("Response for " + uri + " : " + response.body());
                            });
                })
                .toList();

        // Wait for all requests to complete
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
    }
}

Key Best Practices

1. Reuse a single HttpClient instance for better resource management.
2. Use asynchronous methods (sendAsync) for non-blocking and parallel requests.
3. Configure timeouts to avoid hanging.
4. Customize the thread pool if your application has specific concurrency requirements.
5. Properly handle errors and exceptions in both synchronous and asynchronous requests.

By following these guidelines, you can effectively use HttpClient in a multithreaded environment.