I have developed a server-side application that implements a queue mechanism, where incoming requests are intentionally delayed for 5 seconds before sending a response.

On the client side, I am using the latest version of Apache HttpClient 5.3.1 and have configured a 4-second timeout for requests. However, I am observing that some responses are received after the 4-second timeout, even though the server is deliberately holding requests for 5 seconds.

Issue:

• This issue occurs randomly—sometimes requests correctly time out at 4 seconds, but other times, the client still receives responses after 5 seconds.
• There is no consistent pattern to when the timeout is respected versus when responses arrive late.

package com.vendor;
import java.URI;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

import javax.ssl.SSLContext;

import .apache.hc.client5.http.async.methods.SimpleHttpRequest;
import .apache.hc.client5.http.async.methods.SimpleHttpResponse;
import .apache.hc.client5.http.async.methods.SimpleRequestBuilder;
import .apache.hc.client5.http.classic.methods.HttpPost;
import .apache.hc.client5.http.config.RequestConfig;
import .apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
import .apache.hc.client5.http.impl.async.HttpAsyncClientBuilder;
import .apache.hc.client5.http.impl.async.HttpAsyncClients;
import .apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManager;
import .apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManagerBuilder;
import .apache.hc.client5.http.ssl.DefaultClientTlsStrategy;
import .apache.hc.client5.http.ssl.NoopHostnameVerifier;
import .apache.hc.core5.concurrent.FutureCallback;
import .apache.hc.core5.http.ContentType;
import .apache.hc.core5.URIBuilder;
import .apache.hc.core5.reactor.IOReactorConfig;
import .apache.hc.core5.ssl.SSLContexts;
import .apache.hc.core5.ssl.TrustStrategy;
import .apache.hc.core5.util.Timeout;

public class AsyncHttpClientBulkRequests {

    public static void main(String[] args) throws InterruptedException {
        // Number of requests
        AtomicLong successCounter = new AtomicLong(0);
        AtomicLong failCounter = new AtomicLong(0);
        AtomicLong cancelCounter = new AtomicLong(0);
        AtomicLong deadlineCounter = new AtomicLong(0);
        
        int totalRequests = 10000;
        
        try {
            IOReactorConfig ioReactorConfig = IOReactorConfig.custom()
                    .setSoTimeout(Timeout.ofMilliseconds(4000))
                    .setIoThreadCount(Runtime.getRuntime().availableProcessors()).build();
            
            CloseableHttpAsyncClient asyncclient = null;
            
            HttpAsyncClientBuilder builder = HttpAsyncClients.custom();

            setConnectionProperties(builder, createConnectionmanager());

            asyncclient = builder.setIOReactorConfig(ioReactorConfig).build();

            asyncclient.start();

            ExecutorService executorService = Executors.newFixedThreadPool(10);

            List<Future<SimpleHttpResponse>> futures = new ArrayList<>();

            for (int i = 0; i < totalRequests; i++) {
                int requestId = i; // For tracking
                
                URIBuilder uribuilder = new URIBuilder("http://localhost:18888/dynamicResponseThreadWait");

                URI uri = uribuilder.build();

                HttpPost httpPost = new HttpPost(uri);
                SimpleHttpRequest httpRequest = SimpleRequestBuilder.copy(httpPost).build();
                
                 RequestConfig requestConfig = RequestConfig.custom()
                        .setConnectTimeout(4000, TimeUnit.MILLISECONDS)
                        .setResponseTimeout(4000, TimeUnit.MILLISECONDS).build();
                httpRequest.setConfig(requestConfig);
                
                 String requestBody ="{\r\n"
                        + "    \"threadWaitInMilliSeconds\": \"5000\",\r\n"
                        + "    \"ResponseKey\": \"1999999990\",\r\n"
                        + "    \"ResponseData\": {\r\n"
                        + "        \"1999999990\": "+requestId+"\r\n"
                        + "    }\r\n"
                        + "}";
                
                httpRequest.setBody(requestBody, ContentType.APPLICATION_JSON);
                
                long startTime = System.currentTimeMillis(); // Record start time

                /// Submit each request to the client and add a callback
                futures.add(asyncclient.execute(httpRequest, new FutureCallback<>() {
                    @Override
                    public void completed(SimpleHttpResponse response) {
                        
                         long endTime = System.currentTimeMillis();
                         long responseTimeMs = endTime - startTime;

                        successCounter.incrementAndGet();
                        System.err.println("Request:"+ requestId+ " completed with status: "+response.getCode() + ", TimeDiff:"+responseTimeMs);
                    }

                    @Override
                    public void failed(Exception ex) {
                         long endTime = System.currentTimeMillis();
                         long responseTimeMs = endTime - startTime;
                         failCounter.incrementAndGet();
                         
                        //System.out.println("Request "+requestId+ " failed: " +ex.getMessage()+", responseTimeMs:"+responseTimeMs);
                    }

                    @Override
                    public void cancelled() {
                        cancelCounter.incrementAndGet();
                        System.out.printf("Request %d cancelled%n", requestId);
                    }
                    
                    
                }));
                
            }

         // Wait for all requests to complete
            for (Future<SimpleHttpResponse> future : futures) {
                try {
                    future.get(); // Wait for completion
                } catch (ExecutionException | InterruptedException e) {
                   //System.err.println("Error waiting for request to complete: " + e.getMessage());
                }
            }

            executorService.shutdown();
            executorService.awaitTermination(1, TimeUnit.MINUTES);

            System.out.println("All requests completed! TotalCount : " + totalRequests);
            System.out.println("SuccessCounter: "+ successCounter.get());
            System.out.println("FailCounter: "+ failCounter.get());
            System.out.println("CancelCounter: " + cancelCounter.get());
            System.out.println("DeadlineCounter: " + deadlineCounter.get());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
   protected static PoolingAsyncClientConnectionManager createConnectionmanager() throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {
        
        TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
            @Override
            public boolean isTrusted(X509Certificate[] certificate, String authType) {
                return true;
            }
        };

        SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
        return PoolingAsyncClientConnectionManagerBuilder.create().setTlsStrategy(new DefaultClientTlsStrategy(sslContext, NoopHostnameVerifier.INSTANCE)).build();
    }
   
   protected static void setConnectionProperties(HttpAsyncClientBuilder builder, PoolingAsyncClientConnectionManager connectionManager) {
        
        if (connectionManager != null) {
            connectionManager.setDefaultMaxPerRoute(100);
            connectionManager.setMaxTotal(1000);
            builder.setConnectionManager(connectionManager);
        }
    }
}

Expected Outcome: If a request takes longer than 4 seconds, the client should time out and not receive any response.

Actual Outcome: Some requests still receive a response after 5 seconds, even though the response timeout is set to 4 seconds.

**OutPut:**

Request:109 completed with status: 200, TimeDiff:9145
Request:115 completed with status: 200, TimeDiff:9143
Request:105 completed with status: 200, TimeDiff:9146
Request:116 completed with status: 200, TimeDiff:9143