Hilos verdes - Green threads

En la programación de computadoras , los subprocesos verdes o subprocesos virtuales son subprocesos programados por una biblioteca en tiempo de ejecución o una máquina virtual (VM) en lugar de de forma nativa por el sistema operativo (SO) subyacente . Los subprocesos verdes emulan entornos multiproceso sin depender de ninguna capacidad del sistema operativo nativo, y se administran en el espacio del usuario en lugar del espacio del kernel , lo que les permite trabajar en entornos que no tienen soporte nativo para subprocesos.

Etimología

Los subprocesos verdes se refieren al nombre de la biblioteca de subprocesos original para el lenguaje de programación Java (que se lanzó en la versión 1.1 y luego los subprocesos verdes se abandonaron en la versión 1.3 a los subprocesos nativos). Fue diseñado por The Green Team en Sun Microsystems .

Rendimiento

En un procesador de múltiples núcleos , las implementaciones de subprocesos nativos pueden asignar automáticamente trabajo a múltiples procesadores, mientras que las implementaciones de subprocesos verdes normalmente no pueden. Los subprocesos verdes se pueden iniciar mucho más rápido en algunas máquinas virtuales. En las computadoras monoprocesador, sin embargo, el modelo más eficiente aún no se ha determinado claramente.

Los puntos de referencia en computadoras que ejecutan la versión 2.2 del kernel de Linux (obsoleta durante mucho tiempo) han demostrado que:

Los subprocesos ecológicos superan significativamente a los subprocesos nativos de Linux en la activación y sincronización de subprocesos .
Los subprocesos nativos de Linux tienen un rendimiento ligeramente mejor en las operaciones de entrada / salida (E / S) y cambio de contexto .

Cuando un hilo verde ejecuta una llamada al sistema de bloqueo, no solo se bloquea ese hilo, sino que se bloquean todos los hilos dentro del proceso. Para evitar ese problema, los subprocesos verdes deben usar operaciones de E / S asincrónicas , aunque la mayor complejidad del lado del usuario puede reducirse si la máquina virtual que implementa los subprocesos verdes genera procesos de E / S específicos (ocultos para el usuario) para cada E / S. O operación.

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

Los grupos de subprocesos reducen el costo de generar un nuevo subproceso al reutilizar un número limitado de subprocesos.
Los lenguajes que utilizan máquinas virtuales y subprocesos nativos pueden utilizar el análisis de escape para evitar sincronizar bloques de código cuando no sean necesarios.

Hilos verdes en la máquina virtual Java

Implementación original: Green Threads

En Java 1.1 , los subprocesos verdes eran el único modelo de subprocesos utilizado por la máquina virtual Java (JVM), al menos en Solaris . Como los subprocesos verdes tienen algunas limitaciones en comparación con los subprocesos nativos, las versiones posteriores de Java los descartaron en favor de los subprocesos nativos.

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 verdes para minimizar el uso de código nativo y para admitir la migración de sus aislamientos.

Kilim y Quasar son proyectos de código abierto que implementan hilos verdes en versiones posteriores de la JVM modificando el código de bytes de Java producido por el compilador de Java (Quasar también es compatible con Kotlin y Clojure ).

Implementación futura: Project Loom

Project Loom : los subprocesos virtuales son una alternativa liviana programada en modo de usuario a los subprocesos administrados por el sistema operativo estándar. Los subprocesos virtuales se asignan a los subprocesos del sistema operativo en una relación de varios a varios, en contraste con la relación de varios a uno de la implementación original.

Hilos verdes en otros idiomas

Hay algunos otros lenguajes de programación que implementan equivalentes de hilos verdes en lugar de hilos nativos. Ejemplos:

Chicken Scheme utiliza subprocesos ligeros a nivel de usuario basados en continuaciones de primera clase
Lisp común
CPython con greenlet , eventlet y gevent , PyPy
Crystal ofrece fibras
D ofrece fibras , utilizadas para E / S asíncronas
Dyalog APL los denomina hilos
Erlang
Ir todas las goroutines (corrutinas que tienen un control de entrega implícita en ciertos puntos indeterminados) se ejecutan en subprocesos virtuales
Haskell
Julia usa hilos verdes para sus tareas .
Limbo
Lua usa corrutinas para la concurrencia. Lua 5.2 también ofrece una verdadera semántica de rutina en C a través de las funciones lua_yieldk , lua_callk y lua_pcallk . La extensión CoCo permite una verdadera semántica de rutina de C para Lua 5.1.
Nim proporciona E / S asincrónicas y corrutinas
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 a través de corrutinas
PHP admite hilos verdes a través de corrutinas
Ruby antes de la versión 1.9
Raqueta (los hilos nativos también están disponibles a través de Places)
Rust ejecuta los subprocesos del sistema de forma nativa, sin embargo, admite subprocesos verdes a través de bibliotecas de terceros como tokio .
Implementación de ML concurrente de SML / NJ
Smalltalk (la mayoría de los dialectos: Squeak , VisualWorks, GNU Smalltalk , etc.)
Stackless Python admite la multitarea preventiva o la multitarea cooperativa a través de microhilos (denominados tasklets ).
Tcl tiene corrutinas y un bucle de eventos

La máquina virtual Erlang tiene lo que podría llamarse procesos ecológicos : son como los procesos del sistema operativo (no comparten el estado como lo hacen los subprocesos) pero se implementan dentro del Erlang Run Time System (erts). Estos a veces se denominan hilos verdes , pero tienen diferencias significativas con los hilos verdes estándar.

En el caso de GHC Haskell, se produce un cambio de contexto en la primera asignación después de un tiempo de espera configurable. Los subprocesos de GHC también se ejecutan potencialmente en uno o más subprocesos del sistema operativo durante su vida útil (existe una relación de muchos a muchos entre los subprocesos de GHC y los subprocesos del sistema operativo), lo que permite el paralelismo en máquinas de multiprocesamiento simétrico , sin crear subprocesos de SO más costosos de lo necesario para ejecutarse en el número disponible de núcleos.

Occam es inusual en esta lista porque su implementación original se realizó para Transputer y, por lo tanto, no se necesitaba una máquina virtual. Los puertos posteriores a otros procesadores han introducido una máquina virtual modelada en el diseño del Transputer, una opción efectiva debido a los bajos gastos generales involucrados.

La mayoría de las máquinas virtuales Smalltalk no cuentan los pasos de evaluación; sin embargo, la VM aún puede adelantarse al subproceso en ejecución en señales externas (como temporizadores que expiran o E / S disponible). Por lo general , la programación por turnos se utiliza para que un proceso de alta prioridad que se activa con regularidad implemente de manera efectiva la preferencia de tiempo compartido :

 [
    [(Delay forMilliseconds: 50) wait] repeat
 ] forkAt: Processor highIOPriority

Otras implementaciones, por ejemplo, QKS Smalltalk, son siempre de tiempo compartido. A diferencia de la mayoría de las implementaciones de subprocesos ecológicos, QKS también admite la prevención de la inversión de prioridad .

Ver también

Referencias

enlaces externos

" Cuatro para todas las edades ", artículo de JavaWorld sobre hilos verdes
Preguntas frecuentes sobre hilos verdes en hilos Java

Languages

In other projects