¿Por qué no hilos verdes?

Si bien sé que las preguntas sobre esto ya se han cubierto (por ejemplo, https://stackoverflow.com/questions/5713142/green-threads-vs-non-green-threads ), no creo que tenga una respuesta satisfactoria .

La pregunta es: ¿por qué JVM ya no admite hilos verdes?

Dice esto en las preguntas frecuentes de Java de estilo de código :

Un subproceso verde se refiere a un modo de operación para la Máquina virtual Java (JVM) en el que todo el código se ejecuta en un solo subproceso del sistema operativo.

Y esto terminó en java.sun.com :

La desventaja es que el uso de hilos verdes significa que no se aprovechan los hilos del sistema en Linux, por lo que la máquina virtual Java no es escalable cuando se agregan CPU adicionales.

Me parece que la JVM podría tener un grupo de procesos del sistema igual al número de núcleos, y luego ejecutar hilos verdes además de eso. Esto podría ofrecer grandes ventajas cuando tiene una gran cantidad de subprocesos que se bloquean con frecuencia (principalmente porque la JVM actual limita el número de subprocesos).

Pensamientos?

Recuerdo que la JVM abandonó los hilos verdes y se mudó a los hilos nativos. Esto fue por dos razones simples: los hilos verdes eran francamente basura, y había una necesidad de soportar procesadores de múltiples núcleos con el esfuerzo limitado del desarrollador disponible en Sun.

Esto fue una lástima: los hilos verdes proporcionan una abstracción mucho mejor, permitiendo que la concurrencia sea una herramienta útil, no un obstáculo. Pero los hilos verdes no sirven de nada si no se pueden superar varios obstáculos:

• deben usar todos los núcleos de CPU disponibles para ellos

• el cambio de contexto debe ser barato

• I / O puede bloquear cualquier subproceso involucrado en él, pero no cualquier otro subproceso y ciertamente no todos los demás subprocesos, que fue el caso en algunas implementaciones tempranas.

A menudo me he preguntado por qué el subprocesamiento múltiple es tan difícil en Java, pero ahora se está volviendo más claro: en última instancia, tuvo que ver con el cambio a hilos nativos, que son:

• bueno en el uso de todos los núcleos de la CPU

• bueno para ser verdaderamente concurrente, proporcionar E / S independientes, etc.

• lento en el cambio de contexto (en comparación con las mejores implementaciones de hilo verde)

• horriblemente codicioso con la memoria, lo que limita el número máximo utilizable de ellos

• Una pobre abstracción para cualquier base para expresar el mundo real, que es muy concurrente, por supuesto.

Hoy en día, se dedica mucho tiempo al programador a codificar E / S sin bloqueo, futuros, etc. Es una lástima que no tengamos un mejor nivel de abstracción.

A modo de comparación, además de Erlang, el nuevo lenguaje Go hace un buen trabajo de gran concurrencia. El abuelo de todos ellos sigue siendo Occam , todavía un proyecto de investigación en curso.

Un solo proceso que simula múltiples hilos tiene muchos problemas. Una de ellas es que todos los hilos falsos se bloquean en cualquier falla de página.

La alternativa que sugiere, un conjunto de procesos, tiene algunas ventajas y algunas desventajas. La mayor ventaja, el aislamiento de los 'hilos', realmente no te traería mucho aquí. La gran desventaja, la extrema dificultad de implementación y la sincronización menos eficiente, es el factor decisivo aquí.

Sin embargo, estoy de acuerdo en que existen algunas aplicaciones (no Java) donde un conjunto de procesos que podría usar como un conjunto de subprocesos (pero con más aislamiento) sería algo genial. Los hilos comparten casi todo. Con los procesos, puede elegir específicamente qué compartir. Que yo sepa, nadie se ha esforzado por implementarlo todavía.

No habrá ningún beneficio para un código Java promedio. Java no es Erlang, y los programadores de Java no tienen la misma mentalidad que los programadores de Erlang. El lenguaje nunca fue pensado para ser usado de esta manera.

Si desea los verdaderos procesos livianos, use Erlang y cree miles de hilos que se comuniquen a través de mensajes. En Java, tendrá una docena de hilos que comparten una memoria común con mutexes y semáforos. Es solo un modelo de programación diferente, diseñado para un conjunto diferente de problemas.