Pourquoi pas des fils verts?
Bien que je sache que des questions à ce sujet ont déjà été traitées (par exemple https://stackoverflow.com/questions/5713142/green-threads-vs-non-green-threads ), je n'ai pas envie J'ai une réponse satisfaisante.
La question est: pourquoi la JVM ne prend-elle plus en charge les threads verts?
Il le dit sur le style de code Java FAQ :
Un thread vert fait référence à un mode de fonctionnement pour la machine virtuelle Java JVM) dans laquelle tout le code est exécuté dans un thread de système d'exploitation unique.
Et cela sur Java.Sun.com :
L'inconvénient est que l'utilisation de threads verts signifie que les threads système sous Linux ne sont pas exploités et que la machine virtuelle Java n'est pas évolutive lorsque des CPU supplémentaires sont ajoutés.
Il me semble que la JVM pourrait avoir un pool de processus système égal au nombre de cœurs, puis exécuter des threads verts en plus de cela. Cela pourrait offrir de gros avantages lorsque vous avez un très grand nombre de threads qui se bloquent souvent (principalement parce que la JVM actuelle limite le nombre de threads).
Pensées?
Je me souviens de la JVM abandonnant les threads verts et passant aux threads natifs. C'était pour deux raisons simples: les fils verts étaient franchement des déchets, et il était nécessaire de prendre en charge les processeurs multicœurs avec l'effort de développement limité disponible chez Sun.
C'était une honte - les fils verts fournissent une bien meilleure abstraction, permettant à la concurrence d'être un outil utile et non une pierre d'achoppement. Mais les fils verts ne servent à rien si plusieurs obstacles ne peuvent être surmontés:
ils doivent utiliser tous les cœurs de processeur disponibles
le changement de contexte doit être bon marché
Les E/S peuvent bloquer tout thread engagé, mais pas aucun autre thread et certainement pas tous les autres threads, ce qui était le cas dans certaines premières implémentations.
Je me suis souvent demandé pourquoi le multi-threading est si difficile en Java mais cela devient maintenant plus clair - c'était en fin de compte lié au passage aux threads natifs, qui sont:
bon à utiliser tous les cœurs de processeur
bon à être vraiment simultané, fournissant des E/S indépendantes, etc.
lent au changement de contexte (par rapport aux meilleures implémentations de threads verts)
horriblement gourmand de mémoire, limitant ainsi le nombre maximal utilisable d'entre eux
une abstraction médiocre pour toute base pour exprimer le monde réel, qui est bien sûr très concurrente.
De nos jours, beaucoup de temps de programmation va maintenant au codage des E/S non bloquantes, des futurs, etc. C'est une grande honte que nous n'ayons pas de meilleur niveau d'abstraction.
A titre de comparaison, outre Erlang, la nouvelle langue Go fait un bon travail de concurrence énorme. Le grand-papa de tous reste Occam , toujours un projet de recherche en cours.
Un processus unique simulant plusieurs threads a beaucoup de problèmes. L'un d'eux est que tous les fils truqués bloquent sur n'importe quel défaut de page.
L'alternative que vous proposez, un pool de processus, présente des avantages et des inconvénients. Le plus grand avantage, l'isolement des "fils", ne vous apporterait vraiment pas grand-chose ici. Le gros inconvénient, l'extrême difficulté de mise en œuvre et la synchronisation moins efficace, est le tueur à gages ici.
Cependant, je suis d'accord qu'il existe certaines applications (pas Java) où un pool de processus que vous pourriez utiliser comme un pool de threads (mais avec plus d'isolement) serait une bonne chose à avoir. Les discussions partagent à peu près tout. Avec les processus, vous pouvez choisir spécifiquement ce que vous souhaitez partager. À ma connaissance, personne n'a encore fait l'effort de le mettre en œuvre.
Il n'y aura aucun avantage du tout pour un moyen Java code. Java n'est pas Erlang, et Java les programmeurs sont pas dans le même état d'esprit que les programmeurs Erlang. Le langage n'a jamais été conçu pour être utilisé de cette façon.
Si vous voulez la vraie processess légère - utilisez Erlang et créez des milliers de threads communiquant via des messages. Dans Java vous aurez une douzaine de threads partageant une mémoire commune avec des mutex et des sémaphores. Il s'agit simplement d'un modèle de programmation différent, conçu pour un ensemble différent de problèmes.