Hilo verde

En programación informática , un hilo verde es un hilo programado por una biblioteca de tiempo de ejecución o una máquina virtual (VM) en lugar de ser programado de forma nativa por el sistema operativo (SO) subyacente. Los hilos verdes emulan entornos multihilo sin depender de ninguna capacidad nativa del SO y se gestionan en el espacio de usuario en lugar del espacio del kernel , lo que les permite funcionar en entornos que no tienen soporte nativo para hilos. ^{[ 1 ]}

Green Threads hace referencia al nombre de la biblioteca de hilos original para el lenguaje de programación Java (lanzada en la versión 1.1 y posteriormente reemplazada por hilos nativos en la versión 1.3 ). Fue diseñada por el Green Team de Sun Microsystems . ^{[ 2 ]}

Los hilos verdes estuvieron disponibles brevemente en Java entre 1997 y 2000.

Los hilos ligeros comparten un único hilo del sistema operativo mediante concurrencia cooperativa y, por lo tanto, no pueden lograr las mismas ventajas de rendimiento que los hilos del sistema operativo. La principal ventaja de las corrutinas y los hilos ligeros es la facilidad de implementación.

En un procesador multinúcleo , las implementaciones de subprocesos nativos pueden asignar automáticamente el trabajo a varios procesadores, mientras que las implementaciones de subprocesos ligeros normalmente no pueden. ^{[ 1 ] [ 3 ]} Los subprocesos ligeros pueden iniciarse mucho más rápido en algunas máquinas virtuales. Sin embargo, en ordenadores monoprocesador, aún no se ha determinado claramente el modelo más eficiente.

Las pruebas de rendimiento en ordenadores que ejecutan la versión 2.2 del kernel de Linux (lanzada en 1999) han demostrado que: ^{[ 4 ]}

• Los hilos verdes superan significativamente a los hilos nativos de Linux en cuanto a activación y sincronización de hilos .
• Los subprocesos nativos de Linux ofrecen un rendimiento ligeramente superior en las operaciones de entrada/salida (E/S) y de cambio de contexto .

Cuando un hilo verde ejecuta una llamada al sistema bloqueante, no solo se bloquea ese hilo, sino que se bloquean todos los hilos dentro del proceso. ^{[ 5 ]} Para evitar ese problema, los hilos verdes deben usar operaciones de E/S no bloqueantes o asíncronas , aunque la mayor complejidad para el usuario se puede reducir si la máquina virtual que implementa los hilos verdes crea procesos de E/S específicos (ocultos para el usuario) para cada operación de E/S.

También existen mecanismos que permiten el uso de hilos nativos y reducen la sobrecarga de la activación y sincronización de hilos:

• Los grupos de subprocesos reducen el costo de crear un nuevo subproceso al reutilizar un número limitado de subprocesos. ^{[ 6 ]}
• Los lenguajes que utilizan máquinas virtuales e hilos nativos pueden usar análisis de escape para evitar la sincronización de bloques de código cuando no es necesario. ^{[ 7 ]}

En Java 1.1 , los hilos verdes eran el único modelo de subprocesos utilizado por la máquina virtual de Java (JVM), ^{[ 8 ]} al menos en Solaris . Dado que los hilos verdes tienen algunas limitaciones en comparación con los hilos nativos, las versiones posteriores de Java los abandonaron en favor de los hilos nativos. ^{[ 9 ] [ 10 ]}

Una excepción a esto es la máquina virtual Squawk , que es una mezcla entre un sistema operativo para dispositivos de bajo consumo y una máquina virtual Java. Utiliza hilos ligeros para minimizar el uso de código nativo y para facilitar la migración de sus componentes aislados.

Kilim ^{[ 11 ] [ 12 ]} y Quasar ^{[ 13 ] [ 14 ]} son ​​proyectos de código abierto que implementan hilos verdes en versiones posteriores de la JVM modificando el bytecode de Java producido por el compilador de Java (Quasar también admite Kotlin y Clojure ).

Existen otros lenguajes de programación que implementan equivalentes a los hilos ligeros en lugar de los hilos nativos. Ejemplos:

• En C para sistemas POSIX , makecontextproporciona subprocesos cooperativos ligeros. No está incluido en las especificaciones POSIX.1-2008 debido a las diferencias entre sistemas.
• Chicken Scheme utiliza hilos ligeros a nivel de usuario basados ​​en continuaciones de primera clase ^{[ 15 ].}
• Lisp común ^{[ 16 ]}
• CPython admite asyncio de forma nativa desde la versión 3.4, existen implementaciones alternativas como greenlet , eventlet y gevent , PyPy ^{[ 17 ].}
• Crystal ofrece fibras ^{[ 18 ]}
• D ofrece fibras , utilizadas para E/S asíncronas ^{[ 19 ]}
• Dyalog APL los denomina hilos ^{[ 20 ]}
• Erlang ^{[ 21 ]}
• Go implementa las llamadas goroutines ^{[ 22 ]}
• Haskell ^{[ 22 ]}
• Julia utiliza hilos verdes para sus tareas .
• Limbo ^{[ 23 ]}
• Lua utiliza corrutinas para la concurrencia. Lua 5.2 también ofrece una semántica de corrutinas C auténtica a través de las funciones lua_yieldk, lua_callk, y lua_pcallk. La extensión CoCo permite una semántica de corrutinas C auténtica para Lua 5.1.
• Nim proporciona E/S asíncrona y corrutinas.
• OCaml , desde la versión 5.0, admite hilos ligeros a través del módulo Domainslib.Task.
• occam , que prefiere el término proceso en lugar de hilo debido a sus orígenes en la comunicación de procesos secuenciales.
• Perl admite hilos verdes mediante corrutinas.
• PHP admite hilos verdes a través de fibras y corrutinas.
• Racket (los hilos nativos también están disponibles a través de Places ^{[ 24 ]} )
• Ruby antes de la versión 1.9 ^{[ 25 ]}
• Implementación de aprendizaje automático concurrente de SML/NJ
• Smalltalk (la mayoría de los dialectos: Squeak , VisualWorks, GNU Smalltalk , etc.)
• Python sin pila admite multitarea preventiva o multitarea cooperativa a través de microhilos (denominados tasklets ). ^{[ 26 ]}
• Tcl tiene corrutinas y un bucle de eventos ^{[ 27 ]}

La máquina virtual de Erlang cuenta con lo que podríamos llamar procesos verdes : son similares a los procesos del sistema operativo (no comparten estado como los hilos), pero se implementan dentro del Sistema de Tiempo de Ejecución de Erlang (erts). A veces se les denomina hilos verdes , pero presentan diferencias significativas con respecto a los hilos verdes estándar.

En el caso de GHC Haskell, se produce un cambio de contexto en la primera asignación tras un tiempo de espera configurable. Los hilos de GHC también pueden ejecutarse en uno o más hilos del sistema operativo durante su ciclo de vida (existe una relación de muchos a muchos entre los hilos de GHC y los hilos del sistema operativo), lo que permite el paralelismo en máquinas multiprocesadoras simétricas , sin crear hilos del sistema operativo más costosos de los necesarios para ejecutarse en el número de núcleos disponibles.

La mayoría de las máquinas virtuales Smalltalk no contabilizan los pasos de evaluación; sin embargo, la máquina virtual aún puede interrumpir el hilo en ejecución ante señales externas (como la expiración de temporizadores o la disponibilidad de E/S). Normalmente se utiliza la planificación round-robin para que un proceso de alta prioridad que se activa regularmente implemente de forma efectiva la interrupción por tiempo compartido .

[ [( Retraso durante milisegundos: 50 ) esperar ] repetir ] forkAt: Procesador highIOPriority

Otras implementaciones, por ejemplo, QKS Smalltalk, siempre utilizan el método de tiempo compartido. A diferencia de la mayoría de las implementaciones de hilos ligeros, QKS también admite la prevención de la inversión de prioridad .

Los hilos virtuales se introdujeron como una característica de vista previa en Java 19 ^{[ 28 ]} y se estabilizaron en Java 21. ^{[ 29 ]} Las diferencias importantes entre los hilos virtuales y los hilos verdes son:

• Los subprocesos virtuales coexisten con los subprocesos y grupos de subprocesos de la plataforma existentes (no virtuales).
• Los hilos virtuales protegen su abstracción:
  • A diferencia de lo que ocurre con los hilos verdes, el estado de espera en un hilo virtual no bloquea el hilo portador subyacente.
  • Se resta importancia al trabajo con variables locales de hilo y se sugieren valores con ámbito como una alternativa más ligera. ^{[ 30 ]}
• Los hilos virtuales se pueden suspender y reanudar de forma económica, aprovechando la compatibilidad de la JVM con la jdk.internal.vm.Continuationclase especial.
• Los subprocesos virtuales gestionan las llamadas bloqueantes desmontándose de forma transparente del subproceso principal cuando es posible; de ​​lo contrario, compensan aumentando el número de subprocesos de la plataforma.

• Async/await
• Proceso ligero
• Corutina
• máquina virtual Java
• Bloqueo del intérprete global
• Fibra (informática)
• Hilos portátiles de GNU
• Protohilos

• " Cuatro para la historia ", artículo de JavaWorld sobre hilos verdes.
• Preguntas frecuentes sobre hilos verdes en hilos Java