Discussion :

[Opsse]

Bonjour,

Je cherche à effectuer plusieurs requêtes HTTP en parallèle avec Java. Pour cela j'utilise plusieurs threads et les outils Apache (org.apache.http)

Ce que j'ai implémenté

Mon thread principal créé le pool et les configurations :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private PoolingHttpClientConnectionManager	connecManager;
private RequestConfig				reqConfig;
private RotatingProxiesRoutePlanner		routePlanner;
private ConnectionKeepAliveStrategy		strategy;
 
[...]
 
// Init pool connection manager
this.connecManager = new PoolingHttpClientConnectionManager();
this.connecManager.setMaxTotal(settings.getMaxLoadPage());
this.connecManager.setDefaultMaxPerRoute(settings.getMaxLoadPage());
 
// Set request config
this.reqConfig = RequestConfig.custom().setConnectTimeout(settings.getTimeout())
					.setSocketTimeout(settings.getTimeout())
					.setConnectionRequestTimeout(settings.getTimeout()).build();
 
this.routePlanner = new RotatingProxiesRoutePlanner(settings.getProxies());
 
final int keepAlive = settings.getTimeout();
this.strategy = new ConnectionKeepAliveStrategy()
{
	@Override
	public long getKeepAliveDuration(HttpResponse response, HttpContext context)
	{
		return keepAlive;
	}
};

A chaque fois que je créé un thread je lui passe un nouveau client Http que j’initialise de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
CloseableHttpClient client = HttpClients.custom().setConnectionManager(this.connecManager)
						.setDefaultRequestConfig(this.reqConfig)
						.setKeepAliveStrategy(this.strategy)
						.builder.setRoutePlanner(this.routePlanner)
						.build();

A la fin de chaque thread je ferme son client :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

client.close()

Mes problèmes

Lorsque le 1er thread se termine le fait de fermer son client Http fait planter tous les autres threads. Tous les threads en cours lancent un : "java.lang.IllegalStateException: Connection pool shut down"
Je ne comprends pas pourquoi fermer un client perturbe toutes les autres connexions.

Mon second problème, qui n'est surement pas lié, c'est la perte de performance énorme que j'observe lors de l'utilisation de proxy dans la route. Le temps de réponse est au moins multiplié par 10 à chaque requête. J'ai essayé avec plusieurs proxy payant différent et les résultats sont toujours similaire. Ce qui me fait pensé que je dois mal faire quelque chose.
J'ai régulièrement des timeout (java.net.SocketTimeoutException) et des connexion refusé lors de l'utilisation des proxy


J'espère que vous avez des idées à me proposer car moi je suis à court !

[eulbobo]

D'après la javadoc

public final HttpClientBuilder setConnectionManagerShared(boolean shared)
Defines the connection manager is to be shared by multiple client instances.
If the connection manager is shared its life-cycle is expected to be managed by the caller and it will not be shut down if the client is closed.

Essayes de rajouter un setConnectionManagerShared(true) pour éviter que ça coupe à la première fermeture de connexion

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
CloseableHttpClient client = HttpClients.custom().setConnectionManager(this.connecManager)
						.setDefaultRequestConfig(this.reqConfig)
						.setKeepAliveStrategy(this.strategy).setConnectionManagerShared(true)
						.builder.setRoutePlanner(this.routePlanner)
						.build();

Pour le proxy, faudrait nous préciser quel type de proxy, dans quelle configuration réseau (quelle source, où est le proxy, quelle destination)

[Opsse]

J'arrive effectivement à fermer les clients au fur et à mesure avec setConnectionManagerShared(true). Je ne sais pas comment j'ai pu passer à coté après tous les exemples que j'ai vu, merci beaucoup.

Par contre j'ai toujours des "SocketTimeoutException : Read timed out" un peu aléatoire même avec un timeout de 14 secondes.

Pour le proxy

J'ai une liste de proxy distant que je loue à un tiers.
Je choisi le proxy dans une liste grâce à une implémentation de HttpRoutePlanner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class RotatingProxiesRoutePlanner implements HttpRoutePlanner
{
	private List<Proxy> 		proxies;
	private Iterator<Proxy> 	proxiesIt;
 
	public RotatingProxiesRoutePlanner(List<Proxy> proxies)
	{
		this.proxies = proxies;
		this.proxiesIt = null;
	}
 
	@Override
	public HttpRoute determineRoute(HttpHost target, HttpRequest request, HttpContext context) throws HttpException
	{
		Proxy proxy;
 
		// if no proxy
		if(this.proxies.size() <= 0)
			return null;
 
		// if only 1 proxy
		if(this.proxies.size() == 1)
			proxy = this.proxies.get(0);
		else
		{
			[...] sélection d un proxy dans la liste
		}
 
		return new HttpRoute(target, new HttpHost(proxy.getHost(), proxy.getPort());
	}
}

L'application est exécuter sur un serveur personnel et la requête HTTP est à destination d'un serveur web.

La route doit faire : serveur perso -> proxy distant -> serveur web.

J'ai fait des mesures un peu plus précise et mes requêtes sont bien de 3 à 10 fois plus longues avec le proxy.