Quand est-ce que le pool de threads utilisés?

J'ai donc une compréhension de la façon dont Node.js œuvres: il a un seul thread d'écoute qui reçoit un événement, puis délègue à un pool de travail. Le thread de travail informe l'auditeur une fois qu'il termine le travail, et l'auditeur puis renvoie la réponse à l'appelant.

Ma question est: si je me lève d'un serveur HTTP Node.js et d'appeler le sommeil sur un de mes acheminé chemin événements (tels que "/test/sommeil"), l'ensemble du système est livré à une halte. Même le seul thread d'écoute. Mais ma compréhension est que ce code se passe sur le pool de travail.

Maintenant, par contre, quand j'utilise la Mangouste de parler à MongoDB, DB lectures sont une coûteuse opération d'e/S. Nœud semble être en mesure de déléguer le travail à un fil et recevoir le rappel lorsqu'elle est terminée; le temps nécessaire pour charger à partir de la DB ne semble pas bloquer le système.

Comment Node.js décidez d'utiliser un thread du pool vs le thread d'écoute? Pourquoi ne puis-je pas écrire le code d'événement qui dort et seuls les blocs d'un thread du pool?

  • J'ai vu qu'. Ça ne fonctionne toujours pas répondu à ma question. Si le travail a été sur un autre thread, le sommeil ne toucherait que le fil et de ne pas l'auditeur ainsi.
  • Une véritable question, où vous essayez de comprendre quelque chose par vous-même, et quand vous ne pouvez pas trouver la sortie du labyrinthe, vous demander de l'aide.
InformationsquelleAutor Haney | 2014-03-25
  1. 221

    Votre compréhension de la façon fonctionnement du nœud n'est pas correct... mais c'est une idée fausse commune, parce que la réalité de la situation est en fait assez complexe, et généralement se résumait à peu lapidaire des phrases comme "nœud est mono-thread" que la sur-simplifier les choses.

    Pour le moment, nous n'en tenons pas compte explicite des multi-processeurs et multi-threading par cluster et webworker-fils, et juste en parler typique non filetée nœud.

    Nœud s'exécute en une seule boucle d'événements. Il est mono-thread, et vous ne jamais obtenir qu'un seul thread. Tout le code javascript que vous écrivez s'exécute dans cette boucle, et si une opération de blocage qui se passe dans ce code, il va bloquer la totalité de la boucle et rien d'autre se passe jusqu'à la fin. C'est le seul thread à la nature de nœud que vous entendez beaucoup parler. Mais, ce n'est pas la totalité de l'image.

    De certaines fonctions et de modules, généralement écrits en C/C++, le soutien asynchronous I/O. Lorsque vous appelez ces fonctions et méthodes, ils gérer de façon interne de transmettre l'appel à un thread de travail. Par exemple, lorsque vous utilisez le fs module à la demande d'un fichier, le fs module de passe qui appellent à un thread de travail, et que le travailleur attend sa réponse, qu'il présente ensuite retour à la boucle d'événements qui a été barattage sans elle dans l'intervalle. Tout cela est abstrait, loin de vous, le nœud de développeur, et il est soustrait à l'écart du module développeurs par le biais de l'utilisation de libuv.

    Comme l'a souligné Denis Dollfus dans les commentaires (à partir de cette réponse à une question similaire), la stratégie utilisée par libuv pour atteindre asynchronous I/O n'est pas toujours un pool de threads, en particulier dans le cas de la http module une stratégie différente semble être utilisés à cette époque. Pour nos besoins ici, il est surtout important de noter comment le contexte asynchrone est atteint (en utilisant libuv) et que le pool de threads maintenu par libuv est l'une des multiples stratégies proposées par la bibliothèque pour atteindre l'asynchronicité.

    Sur la plupart liés à la tangente, il y a une analyse beaucoup plus profonde de la façon dont nœud atteint l'asynchronicité, et quelques problèmes potentiels et la façon de traiter avec eux, dans cet excellent article. La plupart, il s'étend sur ce que j'ai écrit ci-dessus, mais en outre, il souligne:

    • Externe du module que vous incluez dans votre projet qui rend l'utilisation de C++ natif et libuv est susceptible d'utiliser le pool de threads (pensez: accès de base de données)
    • libuv a un pool de threads par défaut de la taille de 4, et utilise une file d'attente pour gérer l'accès au pool de threads - la conséquence est que, si vous avez 5 DB en cours d'exécution de requêtes tout en allant dans le même temps, l'un d'eux (et de toute autre action asynchrone, qui s'appuie sur le pool de threads) seront en attente pour ces requêtes à terminer avant même d'avoir commencé
    • Vous pouvez réduire ce en augmentant la taille du pool de threads par le biais de la UV_THREADPOOL_SIZE variable d'environnement, aussi longtemps que vous le faites avant le pool de threads est nécessaire et créé le: process.env.UV_THREADPOOL_SIZE = 10;

    Si vous voulez traditionnel multi-processing ou multi-threading dans le nœud, vous pouvez l'obtenir par le biais de la construction dans cluster module ou divers autres modules tels que celui-ci webworker-threads, ou vous pouvez le faux par la mise en œuvre d'une certaine façon de segmentation de votre travail, et manuellement à l'aide de setTimeout ou setImmediate ou process.nextTick pour mettre en pause votre travail et de le continuer plus loin dans la boucle de laisser à d'autres processus complet (mais ce n'est pas recommandé).

    Veuillez noter que si vous écrivez un long cours d'exécution/de blocage de code en javascript, vous êtes probablement faire une erreur. D'autres langues seront d'effectuer beaucoup plus efficacement.

    • Holy crap, cela efface entièrement pour moi. Merci beaucoup @Jason!
    • Pas de problème 🙂 j'ai trouvé moi-même lorsque vous n'êtes pas trop il y a longtemps, et ça a été difficile de venir à une réponse parce que d'un côté, vous avez le C/C++ devs pour qui la réponse est évidente, et, de l'autre vous avez le web devs qui n'ont pas creusé trop profondément dans ces sortes de questions avant. Je ne suis même pas sûr que ma réponse est 100% correcte lorsque vous arrivez vers le bas pour le niveau C, mais c'est juste dans les grandes lignes.
    • Exactement. Je pense que la majorité des développeurs de souffrir de l'Abstraction qui Fuit, surtout avec un environnement et un paradigme que opiniâtre comme Node.js - beaucoup aiment à l'utiliser et de bénéficier de l'async modèle considérablement; peu de gens comprennent ce qui se passe réellement, car ils n'ont jamais ressentir le besoin d'écrire async les bibliothèques elles-mêmes.
    • En utilisant le pool de threads pour les demandes réseau serait un énorme gaspillage de ressources. Selon cette question "Il ne du réseau asynchrone I/O en se basant sur l'async interfaces d'e/S dans différentes plates-formes, telles que epoll, kqueue et IOCP, sans un pool de threads", ce qui fait sens.
    • Merci pour cette précision, @DenisDollfus, je vais mettre à jour la réponse appropriée pour indiquer que des e/S asynchrone utilise des stratégies différentes selon la fonction.
    • Comment est nodejs capable de gérer les connexions simultanées, à condition qu'il s'exécute sur un seul fil? Si je reçois 1000 demandes simultanées, chacun demande d'être traitées l'une après l'autre? Si oui, sera-il pas être un indésirable retard dans la réponse envoyée à chaque requête? Ce qui va se passer si elle reçoit 1000 * 1000 demandes simultanées?
    • il y a deux réponses à votre question - je vais juste les points saillants. Tout d'abord, vous peut utiliser plus d'un processus dans un système de nœuds de l'application grâce à l'utilisation de cluster. Deuxièmement, il existe des exemples concrets de personnes atteignant plus de 100 demandes simultanées - à-dire sans décalage. La raison pour laquelle cela fonctionne est parce qu'un écrit correctement le nœud de l'application fera très peu de travail réel dans son un thread, il va passer la plupart du travail asynchrone des modules écrits avec libuv. Il peut-être un jour touché 1m demandes, mais rien d'autre n'est à proximité que ce soit.
    • Ce que ma perception (sans l'utilisation de tout cluster), c'est que pour 1000 simultanée des requêtes HTTP à chaque demande sera traitée l'une après l'autre, de sorte que la dernière demande (1000e demande) sera servi plus tard en comparaison à la demande servi en premier. (Un décalage semble inévitable ici).
    • Votre perception est erronée. Pour 1000 simultanée des requêtes HTTP, chaque demande démarrer être traitées en série, mais la première demande ne sera pas terminé jusqu'à ce que bien après tous les 1000 demandes sont déjà commencé (pour les non-trivial d'application), le résultat étant qu'ils finissent tous de la même époque qu'il faut pour terminer un. La raison pour cela est que, même si le code javascript que vous écrivez s'exécute dans un thread unique, le (node.js bibliothèque de modules que vous utilisez dans votre javascript sont écrits dans d'autres langues et d'utiliser le pool de threads (voir: ma réponse que nous sommes en commentant)
    • ... cela dit, si vous faites un peu de levage lourd dans les principaux javascript fil directement, ou vous n'avez pas suffisamment de ressources ou de ne pas les gérer de façon appropriée afin de donner une marge suffisante pour le pool de threads, vous pourriez présenter des gal à bas simultanéité seuil - le résultat est que, pour les mêmes ressources système, vous serez généralement plus élevés thruput avec node.js qu'avec d'autres options (s'il existe d'autres systèmes basés sur des événements dans d'autres langues que l'objectif de défi que je n'ai pas vu les récentes repères tout de même) - il est clair qu'un cas de base du modèle surpasse un modèle de thread.
    • Ok. Un modèle de thread démarre un nouveau thread à chaque fois qu'une demande est reçue. Cas de base du modèle ne sera pas invoquer un nouveau thread à chaque fois, mais l'utilisation de la déjà threads disponibles dans la piscine. Quelle est la différence? Un thread dans la piscine occupera également de la mémoire et il en sera de fil juste invoquées pour gérer une nouvelle demande.
    • Nous allons bien au-delà de la portée de cette question, je vous suggère d'aller poser une nouvelle question, de sorte que vous pouvez obtenir une bonne réponse, au minimum vous obtiendrez beaucoup de liens déjà existants explications.
    • Lorsqu'une seule itération de la boucle d'événement de finitions (l'exécution de mon code, en cours d'exécution sur le thread principal), le thread principal va vérifier la file d'attente d'événements pour voir si theres aucun nouvel événement ou de rappel qui devrait être appelé (éventuellement à l'aide d'un thread du pool de threads), et si non, il va exécuter mon code de nouveau dans la prochaine itération?
    • Je veux dire, il y a un seul thread principal qui exécute mon code et vérifie les événements. Il exécute mon code qu'une seule fois, puis commence à vérifier les nouveaux événements dans la file d'attente d'événements - si un événement se produit, de sa fonction de rappel sera exécuté soit sur le thread principal (celui qui a vérifié les événements dans la file d'attente d'événements) ou dans le pool de threads, droit?
    • La plupart du temps correct. Les détails ont peut-être changé un peu depuis la dernière fois que j'ai regardé dedans, mais comme je me souviens, il a travaillé comme ceci: quand le démarrage de l'exécution, la première itération de la boucle d'événements exécute votre code. Si vous faites un appel asynchrone (evented) méthode, il met en place l'événement et, le cas échéant, commence l'exécution asynchrone. La boucle se termine et puis, au début de l'itération suivante, la première chose qu'il fait est de vérifier tiré des événements. Si il en trouve un, il l'exécute dans le thread principal, la manipulation d'appels asynchrones comme avant.
    • Si vous faites un appel asynchrone (evented) méthode, il met en place l'événement - que voulez-vous dire? Si j'appelle une méthode asynchrone, theres aucun cas, je suis juste l'appel d'une méthode.
    • Si il n'y a aucun cas, la méthode n'est pas asynchrone. L'événement pourrait être "DB appel termine et renvoie" ou peut-être "à côté de l'événement de la boucle" ou "3 secondes" ou "réseau d'appel a renvoyé". Si c'est pas l'attente d'un événement futur pour terminer, ensuite, il est exécuté immédiatement et de manière synchrone.
    • Oh, bien sûr, à droite. Mais son généré APRÈS la méthode asynchrone est terminée, pas avant. Donc, il commence d'abord le mode d'exécution asynchrone, puis met en place un événement.
    • Ce que j'aurais dit, c'est l'événement port d'écoute est mise en place.
    • Supposons que mon unique DB requête prendre 2sec pour compléter puis 10 requêtes prendre combien de temps? selon votre réponse, il doit prendre de 4 sec parce que les requêtes s'exécutent dans un ensemble de 5( 4 par thread de travail, 1 attendu que, par listner thread). suis-je le droit?
    • Le thread d'écoute de ne pas exécuter une requête de base de données, donc ça va prendre environ 6 secondes pour que tous les 10 de ces requêtes à remplir par le pool de threads par défaut de la taille de 4). Si vous avez besoin de faire un travail en javascript qui ne nécessite pas les résultats de la requête de base de données pour compléter, par exemple, des demandes qui ne nécessitent pas de travail asynchrone à remplir par le pool de threads, il continuera à travailler dans la boucle principale.

    InformationsquelleAutor Jason
  2. 17

    J'ai donc une compréhension de la façon dont Node.js œuvres: il a un seul thread d'écoute qui reçoit un événement, puis délègue à un pool de travail. Le thread de travail informe l'auditeur une fois qu'il termine le travail, et l'auditeur puis renvoie la réponse à l'appelant.

    Ce n'est pas vraiment précis. Node.js n'a qu'un seul "travailleur" thread qui n'exécution de javascript. Il y a des threads dans le nœud que la poignée de traitement des e /s, mais à les considérer comme des "travailleurs" est une idée fausse. Il y a vraiment juste IO de manutention et de quelques autres détails de nœud interne de la mise en œuvre, mais en tant que programmeur, vous ne pouvez pas influencer leur comportement d'autre qu'un peu de divers paramètres tels que MAX_LISTENERS.

    Ma question est: si je me lève d'un serveur HTTP Node.js et d'appeler le sommeil sur un de mes acheminé chemin événements (tels que "/test/sommeil"), l'ensemble du système est livré à une halte. Même le seul thread d'écoute. Mais ma compréhension est que ce code se passe sur le pool de travail.

    Il n'existe pas de mécanisme du sommeil en JavaScript. Nous pourrions en discuter plus concrètement, si vous avez posté un extrait de code de ce que vous pensez de "sommeil" signifie. Il n'y a pas une telle fonction à appeler pour simuler quelque chose comme time.sleep(30) en python, par exemple. Il y a setTimeout mais qui est fondamentalement PAS le sommeil. setTimeout et setInterval explicitement libération, ne pas bloquer la boucle d'événement de sorte que les autres bits de code peut s'exécuter sur-le-main thread d'exécution. La seule chose que vous pouvez faire est occupé de la boucle de la CPU avec en mémoire les calculs, ce qui sera de fait mourir de faim les principaux thread d'exécution et de rendre votre programme ne répond pas.

    Comment Node.js décidez d'utiliser un thread du pool vs le thread d'écoute? Pourquoi ne puis-je pas écrire le code d'événement qui dort et seuls les blocs d'un thread du pool?

    Réseau IO est toujours asynchrone. Fin de l'histoire. E /s de disque a la fois synchrone et asynchrone Api, donc il n'y a pas de "décision". node.js va se comporter en fonction de l'API des fonctions de base que vous appelez de synchronisation vs normale asynchrone. Par exemple: fs.readFile vs fs.readFileSync. Pour les processus enfants, il y a aussi l' child_process.exec et child_process.execSync Api.

    Règle de base est de toujours utiliser l'Api asynchrones. Les raisons valables d'utiliser l'Api de synchronisation sont pour le code d'initialisation dans un réseau de service avant qu'il est à l'écoute pour les connexions ou dans des scripts simples qui n'acceptent pas les demandes de réseau pour construire des outils et ce genre de chose.

    • Où sont ces Api asynchrones en venir? Je reçois ce que vous dites, mais celui qui a écrit cette Api choisi de IOCP/async. Comment ont-ils choisir de le faire?
    • OK, alors comment aurais-je, comme un Node.js développeur de la bibliothèque, optez pour ces IO threads de traitement? C'est vraiment ma question.
    • Chaque API dans le node.js de base qui prend une fonction de rappel est asynchrone. C'est une décision de conception Ryan Dahl fait quand il a d'abord créé node.js. Fondamentalement, Ryan a conçu le node.js l'API de cette façon parce que, dans son avis de cette façon, une bonne approche de l'écriture à haute performance, haute-simultanéité des serveurs réseau.
    • Vous n'optez pas dans. Vous obtenez tous les temps par défaut. Vous n'avez pas vraiment accepter. Vous utilisez la version synchrone par erreur et que votre programme ne fonctionne pas correctement. Ignorer l' *Synchronisation des Api de base. Ils sont spécialisés et inhabituelle de cas d'utilisation et vous n'avez pas besoin d'eux lors de l'écriture typique node.js de programmes.
    • Sa question est de savoir comment il allait écrire son propre temps intensif de code et de ne pas bloquer.
    • Cela ne répond pas à ma question, Peter. Quelqu'un, quelque part opté dans les IO de la piscine. Les programmes de faire exactement ce que vous leur dites de; il n'y a pas de non-déterminisme. À moins que Node.js utilise un hasard méthode de calcul pour déterminer quand utiliser la piscine et quand ne pas le faire, la Mangouste sait d'opter pour la piscine et écrit le code pour le faire. Comment puis-je écrire le même code à l'opt-in moi-même avec mon propre lib?
    • exactement!!
    • "Toutes les e / s réseau asynchrone". Vraiment. Vous n'optez pas dans. Chaque DB appel que vous faites est le "pool" comme vous l'appelez automatiquement. Il est impossible de refuser, comme il n'existe pas d'API disponible en nœud. node.js juste fonctionne de cette façon tout le temps de conception. Il n'est pas synchrone mise en réseau dans node.js. Votre choix de mot donne l'impression que vous n'êtes pas en train d'essayer de comprendre ce que je dis.
    • Pierre, est-il alors que tous les libs qui utilisent la mise en réseau d'appel Node.js's méthodes de réseautage, qui à son tour l'utilisation de la piscine? Est-ce que vous me dites? Toutes les libs part de la commune Node.js des méthodes qui, elles-mêmes abstraites de la piscine à l'écart? Et il n'y a pas d'autre option?
    • Des extraits de Code sera le guide de cette discussion pour les lieux utiles contre les paragraphes de mal définis en termes de sémantique et de débat. Post un exemple de programme pour illustrer votre point et la question précisément, s'il vous plaît.
    • Oui. Nœud de base en UDP, TCP, HTTP et de la mise en réseau. Il fournit SEULEMENT asynchrone "piscine" basé sur les Api. Tous node.js code dans le monde, sans exception utilise ces de la piscine en fonction des Api asynchrones comme il y a tout simplement tout ce qui est disponible. Système de fichiers et les processus enfants sont une autre histoire, mais le réseau est toujours asynchrone.
    • Attention, Peter, de peur que vous être le fameux pot à sa bouilloire. Il veut savoir comment les écrivains de l'API réseau ne, pas comment les gens qui utilisent le réseau de l'API de le faire. Finalement, j'ai acquis une compréhension de la façon dont le nœud se comporte re: non-blocage des événements parce que je voulais écrire ma propre non-blocage de code qui n'a rien à voir avec mise en réseau ou l'un des autres construits dans des Api asynchrones. Il est assez clair que David veut faire de même.
    • Je ne sais pas ce qu'il veut savoir, parce que sa question est longue et incertaine. Mais ils l'ont fait par écrit libuv (éventuellement). github.com/joyent/libuv
    • Nœud de ne pas utiliser des pools de threads pour IO, il utilise native non-bloquant IO, la seule exception est fs, autant que je sache
    • natif de non-blocage IO est un IOCP qui emploie un pool de threads.
    • est bon, je suis surpris de voir toutes les réponses mentionnant "toutes les e / s se produit dans le pool de threads". C'est tout simplement faux: la plupart des io est dans le même thread, qui utilise libuv asynchrone de réseautage sous le capot (epoll/kqueue/IOCP des appels système sous linux/bsd/windows). Pool de threads IO est seulement pour les opérations de fichiers sur linux où vous ne pouvez pas définir de descripteur de fichier non-bloquant
    • non, il n'est pas, avec IOCP/windows, même pour les opérations de fichier
    • OK, donc vous m'avez dit qu'il ne l'est pas. Soins pour m'éclairer?
    • IOCP est utilisé sur windows et lorsqu'il est utilisé, il fonctionne avec la même boucle (pas un thread séparé) comme epoll base de io. boucle d'événement se produit dans le même thread vm javascript est exécuté

    InformationsquelleAutor Peter Lyons
  3. 0

    Ce malentendu est simplement la différence entre préférentiel de souscription multi-tâches et le multitâche coopératif...

    Le sommeil désactive le carnaval car il y a vraiment une ligne à tous les manèges, et vous avez fermé la porte. Pensez à lui comme "un JS interprète et d'autres choses" et d'ignorer les filets...pour vous, il n'y a qu'un seul thread, ...

    ...afin de ne pas les bloquer.

    InformationsquelleAutor Gregory R. Sudderth