Apache HttpClient - 需要使用MultiThreadedHttpConnectionManager吗？

Question

I have server which receives requests from clients and based on the requests connects to some external website & does some operations.

I am using Apache Commons HttpClient (v 2.0.2) to do these connections (I know it's old, but I have to use it because of other restrictions).

My server is not going to get frequent requests. I think it may be a lot of requests when it's first deployed. Then on it's only going to be a few requests a day. There may be occasional spurts when again there are a lot of requests occasionally.

All connections are going to be one of 3 URLS - they may be http or https

I was thinking of using separate instances of HttpClient for each request

Is there any need for me to use a common HttpClient object & use it with MultiThreadedHttpConnectionManager for different connections. How exactly does MultiThreadedHttpConnectionManager help - does it keep the connection open even after you call releaseConnection? How long will it keep it open?

All my connections are going to be GET & they are going to return 10-20 bytes at most. I am not downloading anything. The reason I am using HttpClient rather than core java libraries is because occasionally, I may want to use HTTP 1.0 (I don't think java classes support this) and I also may want to do Http Redirects automatically.

Answer 1

I use a PoolingHttpClientConnectionManager in a considerably multi-threaded environment and it works very well.

Here's an implementation of a Client pool:

public class HttpClientPool {

    // Single-element enum to implement Singleton.
    private static enum Singleton {

        // Just one of me so constructor will be called once.

        Client;
        // The thread-safe client.
        private final CloseableHttpClient threadSafeClient;
        // The pool monitor.
        private final IdleConnectionMonitor monitor;

        // The constructor creates it - thus late
        private Singleton() {
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
            // Increase max total connection to 200
            cm.setMaxTotal(200);
            // Increase default max connection per route to 200
            cm.setDefaultMaxPerRoute(200);

            // Make my builder.
            HttpClientBuilder builder = HttpClients.custom()
                    .setRedirectStrategy(new LaxRedirectStrategy())
                    .setConnectionManager(cm);
            // Build the client.
            threadSafeClient = builder.build();
            // Start up an eviction thread.
            monitor = new IdleConnectionMonitor(cm);
            // Start up the monitor.
            Thread monitorThread = new Thread(monitor);
            monitorThread.setDaemon(true);
            monitorThread.start();
        }

        public CloseableHttpClient get() {
            return threadSafeClient;
        }

    }

    public static CloseableHttpClient getClient() {
        // The thread safe client is held by the singleton.
        return Singleton.Client.get();
    }

    public static void shutdown() throws InterruptedException, IOException {
        // Shutdown the monitor.
        Singleton.Client.monitor.shutdown();
    }

    // Watches for stale connections and evicts them.
    private static class IdleConnectionMonitor implements Runnable {

        // The manager to watch.

        private final PoolingHttpClientConnectionManager cm;
        // Use a BlockingQueue to stop everything.
        private final BlockingQueue<Stop> stopSignal = new ArrayBlockingQueue<Stop>(1);

        IdleConnectionMonitor(PoolingHttpClientConnectionManager cm) {
            this.cm = cm;
        }

        public void run() {
            try {
                // Holds the stop request that stopped the process.
                Stop stopRequest;
                // Every 5 seconds.
                while ((stopRequest = stopSignal.poll(5, TimeUnit.SECONDS)) == null) {
                    // Close expired connections
                    cm.closeExpiredConnections();
                    // Optionally, close connections that have been idle too long.
                    cm.closeIdleConnections(60, TimeUnit.SECONDS);
                }
                // Acknowledge the stop request.
                stopRequest.stopped();
            } catch (InterruptedException ex) {
                // terminate
            }
        }

        // Pushed up the queue.
        private static class Stop {

            // The return queue.

            private final BlockingQueue<Stop> stop = new ArrayBlockingQueue<Stop>(1);

            // Called by the process that is being told to stop.
            public void stopped() {
                // Push me back up the queue to indicate we are now stopped.
                stop.add(this);
            }

            // Called by the process requesting the stop.
            public void waitForStopped() throws InterruptedException {
                // Wait until the callee acknowledges that it has stopped.
                stop.take();
            }

        }

        public void shutdown() throws InterruptedException, IOException {
            // Signal the stop to the thread.
            Stop stop = new Stop();
            stopSignal.add(stop);
            // Wait for the stop to complete.
            stop.waitForStopped();
            // Close the pool.
            HttpClientPool.getClient().close();
            // Close the connection manager.
            cm.close();
        }

    }

}

All you need to do is CloseableHttpResponse conversation = HttpClientPool.getClient().execute(request); and when you've finished with it, just close it and it will be returned to the pool.

Answer 2

I think it all depends on what your SLAs are and if the the performance is within the acceptable/expected response times. Your solution will work without any issues but it is not scalable if your application demands grow over time.

Using MultiThreadedHttpConnectionManager is much more elegant/scalable solution than having to manage 3 independent HttpClient objects.