Best Practice per l'utilizzo di HttpClient in multithreading ambiente

Question

Per un po ', ho utilizzato HttpClient in un ambiente multithreading. Per ogni filo, quando si avvia una connessione, si creerà una nuova istanza HttpClient.

Di recente, ho scoperto che, utilizzando questo approccio, può causare all'utente di avere troppe porte vengono aperte, e la maggior parte dei collegamenti sono in stato TIME_WAIT.

http: //www.opensubscriber. com/message/commons-httpclient-dev@jakarta.apache.org/86045.html

Quindi, invece di ciascuno facendo filetto:

HttpClient c = new HttpClient();
try {
    c.executeMethod(method);
}
catch(...) {
}
finally {
    method.releaseConnection();
}

Abbiamo in programma di avere:

[METODO A]

// global_c is initialized once through
// HttpClient global_c = new HttpClient(new MultiThreadedHttpConnectionManager());

try {
    global_c.executeMethod(method);
}
catch(...) {
}
finally {
    method.releaseConnection();
}

In una situazione normale, global_c sarà accessibile da 50 ++ thread simultaneamente. Mi chiedevo, sarà presente creare eventuali problemi di prestazioni? È MultiThreadedHttpConnectionManager utilizza un meccanismo senza blocchi per attuare la sua politica di thread-safe?

Se 10 thread utilizzano global_c, saranno gli altri 40 thread essere bloccato?

O sarebbe meglio se, in ogni filo, creo un'istanza di un HttpClient, ma la liberatoria la gestione connessione in modo esplicito?

[METODO B]

MultiThreadedHttpConnectionManager connman = new MultiThreadedHttpConnectionManager();
HttpClient c = new HttpClient(connman);
try {
      c.executeMethod(method);
}
catch(...) {
}
finally {
    method.releaseConnection();
    connman.shutdown();
}

Sarà connman.shutdown () soffrono problemi di prestazioni?

Si può sapere quale metodo (A o B) è meglio, per l'applicazione utilizzando un 50 ++ discussioni?

Answer 1

Metodo A è consigliato da HttpClient comunità degli sviluppatori.

Si prega di fare riferimento http: //www.mail- archive.com/httpclient-users@hc.apache.org/msg02455.html per ulteriori dettagli.

Answer 2

Sicuramente Metodo A causa sua riunite e thread-safe.

Se si utilizza HttpClient 4.x, la gestione connessione si chiama ThreadSafeClientConnManager . Vedere questo collegamento rel="noreferrer"> per ulteriori dettagli (scorrere fino alla voce " pooling gestione connessione "). Ad esempio:

    HttpParams params = new BasicHttpParams();
    SchemeRegistry registry = new SchemeRegistry();
    registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    ClientConnectionManager cm = new ThreadSafeClientConnManager(params, registry);
    HttpClient client = new DefaultHttpClient(cm, params);

Answer 3

La mia lettura dei documenti è che HttpConnection per sé non è trattato come thread-safe, e quindi MultiThreadedHttpConnectionManager fornisce un pool riutilizzabile di HttpConnections, si dispone di un unico MultiThreadedHttpConnectionManager condiviso da tutte le discussioni e inizializzato esattamente una volta. Quindi è necessario un paio di piccoli perfezionamenti per l'opzione A.

MultiThreadedHttpConnectionManager connman = new MultiThreadedHttpConnectionManag

Quindi ogni thread dovrebbe usare la sequenza per ogni richiesta, ottenendo in contatto dalla piscina e rimetterlo al termine del suo lavoro - utilizzando un blocco finally può essere buona. Si dovrebbe anche codice per la possibilità che la piscina non ha connessioni disponibili ed elaborare l'eccezione di timeout.

HttpConnection connection = null
try {
    connection = connman.getConnectionWithTimeout(
                        HostConfiguration hostConfiguration, long timeout) 
    // work
} catch (/*etc*/) {/*etc*/} finally{
    if ( connection != null )
        connman.releaseConnection(connection);
}

Come si utilizza un pool di connessioni non sarà effettivamente essere la chiusura delle connessioni e quindi questo non dovrebbe colpire il problema TIME_WAIT. Questo approccio fa assuume che ciascun filo non sporga al collegamento a lungo. Si noti che truffatore si è lasciata aperta.

Answer 4

Credo che si desidera utilizzare ThreadSafeClientConnManager.

Si può vedere come funziona qui: http: //foo.jasonhudgins.com/2009/08/http-connection-reuse-in-android.html

O nel AndroidHttpClient che usa internamente.

Answer 5

Con HttpClient 4.5 si può fare questo:

CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(new PoolingHttpClientConnectionManager()).build();

Si noti che questo implementa Closeable (per lo spegnimento della gestione connessione).