Pourquoi pas les fils verts?

Bien que je sache que des questions à ce sujet ont déjà été abordées (par exemple, https://stackoverflow.com/questions/5713142/green-threads-vs-non-green-threads ), je n'ai pas l'impression d'avoir une réponse satisfaisante. .

La question qui se pose est la suivante: pourquoi la machine virtuelle Java ne prend-elle plus en charge les threads verts?

Voici ce que dit la FAQ Java de style code :

Un thread vert fait référence à un mode de fonctionnement de la machine virtuelle Java (JVM) dans lequel tout le code est exécuté dans un seul thread du système d'exploitation.

Et ceci 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 processeurs supplémentaires sont ajoutés.

Il me semble que la machine virtuelle Java pourrait avoir un pool de processus système égal au nombre de cœurs, puis exécuter des threads verts par dessus. Cela pourrait offrir de gros avantages lorsque vous avez un très grand nombre de threads qui bloquent souvent (principalement parce que les JVM actuelles limitent le nombre de threads).

Pensées?

Je me souviens de la JVM abandonnant les threads verts et passant à des threads natifs. Cela s'explique par deux raisons simples: les threads verts sont franchement nuls et il était nécessaire de prendre en charge les processeurs multicœurs avec les efforts de développement limités disponibles chez Sun.

C'était une honte - les threads verts fournissent une bien meilleure abstraction, ce qui permet à la concurrence d'accès d'être un outil utile et non une pierre d'achoppement. Mais les fils verts ne sont d'aucune utilité 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 tous les threads qui y sont engagés, mais pas les autres threads, et certainement pas tous les autres threads, ce qui était le cas dans certaines implémentations antérieures.

Je me suis souvent demandé pourquoi le multi-threading est si difficile en Java, mais cela devient de plus en plus clair: c'était en fin de compte le passage aux threads natifs, qui sont:

• bon à utiliser tous les noyaux de cpu

• bon à être vraiment concurrent, fournissant des entrées / sorties indépendantes, etc.

• lent au changement de contexte (comparé aux meilleures implémentations de thread vert)

• horriblement gourmand en mémoire, limitant ainsi le nombre maximum utilisable d'entre eux

• une piètre abstraction pour toute base permettant d'exprimer le monde réel, ce qui est hautement concourant bien sûr.

De nos jours, les programmeurs consacrent beaucoup de temps à coder des E / S non bloquantes, des contrats à terme, etc. Il est dommage que nous n'ayons pas un meilleur niveau d'abstraction.

À titre de comparaison, à part Erlang, la nouvelle langue de Go fait un bon travail de grande concurrence. Le grand-père de tous reste Occam , un projet de recherche en cours.

Un seul processus simulant plusieurs threads pose de nombreux problèmes. L'un d'eux est que tous les faux fils stagnent 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 gros avantage, l'isolement des "fils", ne vous mènerait vraiment pas beaucoup ici. Le gros inconvénient, l’extrême difficulté de mise en oeuvre et une synchronisation moins efficace, est le tueur face à la concurrence.

Cependant, je conviens qu'il existe certaines applications (pas Java) dans lesquelles un pool de processus que vous pourriez utiliser comme un pool de threads (mais avec plus d'isolation) serait une excellente chose. Les fils partagent à peu près tout. Avec les processus, vous pouvez choisir spécifiquement ce que vous souhaitez partager. À ma connaissance, personne n’a encore tenté de la mettre en œuvre.

Il n'y aura aucun avantage pour un code Java moyen. Java n'est pas Erlang et les programmeurs Java ne 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 légèreté du processus - utilisez Erlang et créez des milliers de threads communiquant via des messages. En Java, une douzaine de threads partagent une mémoire commune avec des mutex et des sémaphores. C'est juste un modèle de programmation différent, conçu pour un ensemble différent de problèmes.