Quelle est la différence entre thread par connexion et thread par requête?
Pouvez-vous s'il vous plaît expliquer les deux méthodologies qui ont été implémentées dans différentes implémentations de servlets:
- Fil par connexion
- Fil par demande
Laquelle des deux stratégies ci-dessus est plus efficace et pourquoi?
Laquelle des deux stratégies ci-dessus est plus efficace et pourquoi?
Le nombre de threads par demande est supérieur à celui des threads par connexion.
Les threads Java sont assez coûteux, utilisant généralement un segment de mémoire de 1 Mo chacun, qu'ils soient actifs ou inactifs. Si vous attribuez à chaque connexion son propre thread, celui-ci restera généralement inactif entre les demandes successives de la connexion. En fin de compte, le cadre doit cesser d'accepter de nouvelles connexions (car il ne peut plus créer de threads) ou commencer à déconnecter les anciennes connexions (ce qui entraîne une rupture de connexion si/quand l'utilisateur se réveille).
La connexion HTTP nécessite beaucoup moins de ressources qu'une pile de thread, bien que le nombre de connexions ouvertes par adresse IP soit limité à 64 Ko, en raison du fonctionnement de TCP/IP.
En revanche, dans le modèle thread-per-request, le thread n'est associé que pendant le traitement d'une requête. Cela signifie généralement que le service a besoin de moins de threads pour gérer le même nombre d'utilisateurs. Et comme les threads utilisent des ressources importantes, cela signifie que le service sera plus évolutif.
(Remarquez que thread-per-request ne signifie pas que le framework doit fermer la connexion TCP entre les requêtes HTTP ...)
Cela dit, le modèle de threads par requête n'est pas idéal lorsqu'il y a de longues pauses pendant le traitement de chaque requête. (Et cela est particulièrement déconseillé lorsque le service utilise l'approche comet qui implique de garder le flux de réponse ouvert pendant longtemps.) La méthode de requête de servlet pour suspendre son association avec le thread de requête actuel. Cela libère le fil pour aller traiter une autre demande.
Si l'application Web peut être conçue pour utiliser le mécanisme "asynchrone", il est probable qu'elle soit plus évolutive que thread par requête ou thread par connexion.
SUIVI
Supposons une seule page Web avec 1000 images. Cela se traduit par 1001 requêtes HTTP. En outre, supposons que les connexions persistantes HTTP soient utilisées. Avec la stratégie TPR, cela se traduira par 1001 opérations de gestion de pool de threads (TPMO). Avec la stratégie de TPC, cela se traduira par 1 TPMO ... Maintenant, en fonction des coûts réels pour un seul TPMO, je peux imaginer des scénarios dans lesquels TPC pourrait avoir une meilleure performance que TPR.
Je pense qu'il y a certaines choses que vous n'avez pas considérées:
Le navigateur Web confronté à de nombreuses URL à extraire pour compléter une page peut très bien ouvrir plusieurs connexions.
Avec les connexions persistantes et TPC, le thread doit attendre que le client reçoive la réponse et envoie la demande suivante. Ce temps d'attente pourrait être important si la latence du réseau est élevée.
Le serveur n'a aucun moyen de savoir quand une connexion donnée (persistante) peut être fermée. Si le navigateur ne le ferme pas, il pourrait "s'attarder", en attachant le thread TPC jusqu'à ce que le serveur expire la connexion.
Les frais généraux du TPMO ne sont pas énormes, en particulier lorsque vous séparez les frais généraux du pool des frais généraux du commutateur de contexte. (Vous devez le faire, car TPC générera des commutations de contexte sur des connexions persistantes; voir ci-dessus.)
Mon sentiment est que ces facteurs sont susceptibles de l'emporter sur l'économie TPMO d'avoir un seul thread dédié à chaque connexion.
HTTP 1.1 - Prend en charge connexions persistantes , ce qui signifie que plusieurs demandes/réponses peuvent être reçues/envoyées à l'aide de la même connexion HTTP. Pour exécuter les demandes reçues à l'aide de la même connexion en parallèle, new Thread est créé pour chaque demande.
HTTP 1.0 - Dans cette version, une seule demande a été reçue à l'aide de la connexion et la connexion a été fermée après l'envoi de la réponse. Donc, un seul thread a été créé pour une connexion.
Thread per connection est le concept de réutilisation du même HTTP Connection à partir de multiple requests ( keep-alive ).
Thread per request créera un thread pour each request à partir d'une client. Le serveur peut créer un nombre de threads selon request.
Thread per request créera un thread pour chaque requête HTTP reçue par le serveur.
Un thread par connexion réutilisera la même connexion HTTP à partir de plusieurs requêtes (keep-alive) .AKA Connexion persistante HTTP , Mais veuillez noter que cela n'est pris en charge que depuis HTTP 1.1
Thread Per Request est plus rapide car la plupart des conteneurs Web utilisent le pool de threads.
Nombre maximal de connexions parallèles à définir sur le nombre de cœurs de votre serveur. Plus de cœurs => plus de fils parallèles.
Voyez ici comment configurer ... Tomcat 6: http://Tomcat.Apache.org/Tomcat-6.0-doc/config/executor.html
Tomcat 7: http://Tomcat.Apache.org/Tomcat-7.0-doc/config/executor.html
Exemple
Fil par requête devrait être meilleur, car il réutilise les threads, alors que certains clients peuvent être inactifs. Si vous avez beaucoup d'utilisateurs simultanés, ils pourraient être servis avec moins de threads et avoir le même nombre de threads serait plus coûteux. Il y a aussi une autre considération - nous ne savons pas si l'utilisateur travaille toujours avec une application, nous ne pouvons donc pas savoir quand détruire un thread. Avec un mécanisme de thread par requête, nous utilisons simplement un pool de threads.