Apache HttpClient - Plusieurs threads

Un programme multithread contient deux ou plusieurs parties qui peuvent s'exécuter simultanément et chaque partie peut gérer une tâche différente en même temps en utilisant de manière optimale les ressources disponibles.

Vous pouvez exécuter des requêtes à partir de plusieurs threads en écrivant un programme HttpClient multithread.

Si vous souhaitez exécuter plusieurs demandes client à partir de threads consécutivement, vous devez créer un ClientConnectionPoolManager. Il maintient une piscine deHttpClientConnections et sert plusieurs demandes de threads.

Le gestionnaire de connexions regroupe les connexions en fonction de l'itinéraire. Si le gestionnaire a des connexions pour un itinéraire particulier, il répond aux nouvelles demandes dans ces itinéraires en louant une connexion existante du pool, au lieu d'en créer une nouvelle.

Suivez les étapes pour exécuter les demandes de plusieurs threads -

Étape 1 - Création du gestionnaire de pool de connexions client

Créez le gestionnaire de pool de connexions client en instanciant le PoolingHttpClientConnectionManager classe.

PoolingHttpClientConnectionManager connManager = new
   PoolingHttpClientConnectionManager();

Étape 2 - Définissez le nombre maximum de connexions

Définissez le nombre maximal de connexions dans le pool à l'aide du setMaxTotal() méthode.

//Set the maximum number of connections in the pool
connManager.setMaxTotal(100);

Étape 3 - Créer un objet ClientBuilder

Créer un ClientBuilder Objet en définissant le gestionnaire de connexions à l'aide de setConnectionManager() méthode comme indiqué ci-dessous -

HttpClientBuilder clientbuilder =
HttpClients.custom().setConnectionManager(connManager);

Étape 4 - Créez les objets de requête HttpGet

Instanciez la classe HttpGet en passant l'URI souhaité à son constructeur en tant que paramètre.

HttpGet httpget1 = new HttpGet("URI1");
HttpGet httpget2 = new HttpGet("URI2");
. . . . . . . . . . . .

Étape 5 - Implémentation de la méthode d'exécution

Assurez-vous que vous avez créé une classe, en avez fait un thread (soit en étendant la classe de thread, soit en implémentant l'interface Runnable) et en implémentant la méthode run.

public class ClientMultiThreaded extends Thread {
   public void run() {
      //Run method implementation . . . . . . . . . .
   }
}

Étape 6 - Créer des objets Thread

Créez des objets de thread en instanciant la classe Thread (ClientMultiThreaded) créée ci-dessus.

Passez un objet HttpClient, un objet HttpGet respectif et un entier représentant l'ID à ces threads.

ClientMultiThreaded thread1 = new ClientMultiThreaded(httpclient,httpget1, 1);
ClientMultiThreaded thread2 = new ClientMultiThreaded(httpclient,httpget2, 2);
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Étape 7 - Démarrez et rejoignez les discussions

Démarrez tous les threads en utilisant start() et rejoignez-les en utilisant la jointure method().

thread1.start();
thread2.start();
. . . . . . . .
thread1.join();
thread2.join();
. . . . . . . . . . . .

Étape 8 - Exécuter la mise en œuvre de la méthode

Dans la méthode run, exécutez la demande, récupérez la réponse et imprimez les résultats.

Exemple

L'exemple suivant montre l'exécution de requêtes HTTP simultanément à partir de plusieurs threads. Dans cet exemple, nous essayons d'exécuter diverses requêtes à partir de différents threads et essayons d'imprimer l'état, et le nombre d'octets lus par chaque client.

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;

public class ClientMultiThreaded extends Thread {
   CloseableHttpClient httpClient;
   HttpGet httpget;
   int id;
 
   public ClientMultiThreaded(CloseableHttpClient httpClient, HttpGet httpget,
   int id) {
      this.httpClient = httpClient;
      this.httpget = httpget;
      this.id = id;
   }
   @Override
   public void run() {
      try{
         //Executing the request
         CloseableHttpResponse httpresponse = httpClient.execute(httpget);

         //Displaying the status of the request.
         System.out.println("status of thread "+id+":"+httpresponse.getStatusLine());

         //Retrieving the HttpEntity and displaying the no.of bytes read
         HttpEntity entity = httpresponse.getEntity();
         if (entity != null) {
            System.out.println("Bytes read by thread thread "+id+":
               "+EntityUtils.toByteArray(entity).length);
         }
      }catch(Exception e) {
         System.out.println(e.getMessage());
      }
   }
      
   public static void main(String[] args) throws Exception {

      //Creating the Client Connection Pool Manager by instantiating the PoolingHttpClientConnectionManager class.
      PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();

      //Set the maximum number of connections in the pool
      connManager.setMaxTotal(100);

      //Create a ClientBuilder Object by setting the connection manager
      HttpClientBuilder clientbuilder = HttpClients.custom().setConnectionManager(connManager);
 
      //Build the CloseableHttpClient object using the build() method.
      CloseableHttpClient httpclient = clientbuilder.build();

      //Creating the HttpGet requests
      HttpGet httpget1 = new HttpGet("http://www.tutorialspoint.com/");
      HttpGet httpget2 = new HttpGet("http://www.google.com/");
      HttpGet httpget3 = new HttpGet("https://www.qries.com/");
      HttpGet httpget4 = new HttpGet("https://in.yahoo.com/");
 
      //Creating the Thread objects
      ClientMultiThreaded thread1 = new ClientMultiThreaded(httpclient,httpget1, 1);
      ClientMultiThreaded thread2 = new ClientMultiThreaded(httpclient,httpget2, 2);
      ClientMultiThreaded thread3 = new ClientMultiThreaded(httpclient,httpget3, 3);
      ClientMultiThreaded thread4 = new ClientMultiThreaded(httpclient,httpget4, 4);

      //Starting all the threads
      thread1.start();
      thread2.start();
      thread3.start();
      thread4.start();

      //Joining all the threads
      thread1.join();
      thread2.join();
      thread3.join();
      thread4.join();
   }
}

Production

Lors de l'exécution, le programme ci-dessus génère la sortie suivante -

status of thread 1: HTTP/1.1 200 OK
Bytes read by thread thread 1: 36907
status of thread 2: HTTP/1.1 200 OK
Bytes read by thread thread 2: 13725
status of thread 3: HTTP/1.1 200 OK
Bytes read by thread thread 3: 17319
status of thread 4: HTTP/1.1 200 OK
Bytes read by thread thread 4: 127018