Fils verts vs fils non verts
Je voudrais comprendre les avantages fournis par ce type de threads.
Dans quels environnements les fils verts sont-ils meilleurs que les fils non verts? Certains disent que les fils verts sont meilleurs pour les processeurs multicœurs.
Tout problème de comportement attendu.
L'article Wikipedia Green Threads l'explique très bien.
Les fils verts sont des "fils de niveau utilisateur". Ils sont planifiés par un processus de niveau utilisateur "ordinaire", et non par le noyau. Ils peuvent donc être utilisés pour simuler le multi-threading sur des plateformes qui ne fournissent pas cette capacité.
Dans le contexte de Java spécifiquement, les fils verts appartiennent au passé. Voir l'article JDK 1.1 for Solaris Developer's Guide . (Il s'agit de Solaris, mais du fait que les fils verts ne sont plus utilisés est valable pour les plateformes habituelles).
Les threads verts ont été abandonnés dans la JVM Sun pour Linux à partir de la sortie de la version 1.3 (voir Technologie Java [tm] sur la plate-forme Linux sur archive.org). Cela remonte à 2000. Pour Solaris, les threads natifs étaient disponibles à partir de JDK 1.2. Cela remonte à 1998. Je ne pense même pas qu'il y ait jamais eu d'implémentation de thread vert pour Windows, mais je ne trouve pas de référence pour cela.
Il y a quelques exceptions comme indiqué dans l'article Wikipédia, je recueille principalement pour les appareils de faible puissance (intégrés).
La mémoire du thread vert est allouée à partir du tas plutôt que d'avoir une pile créée pour elle par le système d'exploitation. Cela peut potentiellement donner un ordre de grandeur ou plus d'augmentation des threads simultanés. Comme d'autres personnes l'ont mentionné, cela ne profiterait pas automatiquement de plusieurs processeurs, mais le cas d'utilisation est généralement pour bloquer les E/S - par exemple, les threads verts peuvent vous permettre de gérer 100 000 connexions simultanées au lieu de 10 000.
En d'autres termes, les threads verts sont meilleurs pour les opérations liées à IO à une certaine échelle).
Les threads verts sont des threads implémentés au niveau de l'application plutôt que dans le système d'exploitation. Cela se fait généralement lorsque le système d'exploitation ne fournit pas d'API de thread, ou qu'il ne fonctionne pas comme vous le souhaitez.
Ainsi, l'avantage est que vous obtenez une fonctionnalité semblable à un thread. L'inconvénient est que les threads verts ne peuvent pas réellement utiliser plusieurs cœurs.
Il y avait quelques premières JVM qui utilisaient des threads verts (IIRC le port JVM Blackdown pour Linux), mais de nos jours toutes les JVM traditionnelles utilisent de vrais threads. Il peut y avoir des JVM intégrées qui utilisent toujours des threads verts.
Les threads verts sont nettement plus rapides que les threads natifs lorsqu'ils ont plus de threads actifs que les processeurs.
Java prend initialement en charge les threads verts, mais contrairement à la plupart des implémentations de threads verts modernes, il ne peut pas évoluer sur plusieurs processeurs, ce qui rend Java incapable d'utiliser plusieurs cœurs.
Puis Java a supprimé le filetage vert afin de ne compter que sur les fils natifs. Cela a fait Java les fils plus lents que les fils verts).
Veuillez noter que je ne parle pas spécifiquement de l'implémentation Java de threads verts qui présentait des inconvénients car, contrairement à d'autres implications de threads verts, elle ne pouvait pas évoluer dans un système multicœur ou multiprocesseur.
Les fils verts sont des fils de niveau utilisateur plutôt que des fils de niveau noyau. Ils sont planifiés par les bibliothèques utilisateur plutôt que par le noyau. Vous pouvez avoir votre propre mécanisme de planification pour planifier les threads plutôt que de compter sur le planificateur du système d'exploitation.
Les threads verts émulent des environnements multithreads sans compter sur des capacités de système d'exploitation natif, et ils sont gérés dans l'espace utilisateur au lieu de l'espace du noyau, ce qui leur permet de travailler dans des environnements qui ne prennent pas en charge les threads natifs
Performace:
Sur un processeur multicœur, les implémentations de threads natives peuvent affecter automatiquement le travail à plusieurs processeurs, contrairement aux implémentations de threads vertes. Les threads verts surpassent considérablement les threads natifs Linux sur l'activation et la synchronisation des threads.
Lorsqu'un thread vert exécute un appel système de blocage, non seulement ce thread est bloqué, mais tous les threads du processus sont bloqués.
Les fils verts ne sont pas planifiés par le système d'exploitation.
Cela signifie que leur planification se produit dans l'espace utilisateur et n'est pas gérée par le noyau. Cela signifie que les threads verts ne peuvent généralement pas être utilisés pour utiliser tous les cœurs de processeur.
Pour toute plate-forme grand public exécutant Java ces jours-ci (par exemple x86 ou x64), vous utiliserez de vrais threads.
Java Multi-Threading est implémenté par deux modèles:
- Modèle de fil vert
- Modèle de système d'exploitation natif
Green Thread Model: Le Thread qui est géré par JVM, sans prendre en charge le système d'exploitation sous-jacent est appelé Green Thread. Très peu de systèmes d'exploitation comme Sun Solaris prennent en charge le modèle de thread vert. Il est obsolète et non recommandé à utiliser.
Modèle de système d'exploitation natif: Le thread géré par la JVM à l'aide du système d'exploitation sous-jacent est appelé Modèle de système d'exploitation natif. Tous les systèmes d'exploitation Windows prennent en charge le modèle de système d'exploitation natif.