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 hacerlo 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. [1]
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 . [2]
Actuación
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. [1] [3] 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: [4]
- 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. [5] Para evitar ese problema, los subprocesos verdes deben utilizar operaciones de E / S asíncronas , 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 operación de E / S. [ cita requerida ]
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. [6]
- 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. [7]
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 subprocesamiento utilizado por la máquina virtual Java (JVM), [8] 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. [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 verdes para minimizar el uso de código nativo y para admitir la migración de sus aislamientos.
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 es compatible con Kotlin y Clojure ).
Implementación futura: Project Loom
Project Loom : los subprocesos virtuales son una alternativa ligera 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 [15]
- Lisp común [16]
- CPython con greenlet , eventlet y gevent , PyPy [17]
- Crystal ofrece fibras [18]
- D ofrece fibras , utilizadas para E / S asíncronas como base para tareas en el marco web Vibe.d
- Dyalog APL los denomina hilos [19]
- Erlang [20]
- Go [21] todas las goroutines (coroutine que tienen un control de entrega implícita en ciertos puntos indeterminados) se ejecutan en subprocesos virtuales
- Haskell [21]
- Julia usa hilos verdes para sus tareas .
- Limbo [22]
- 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.
- PHP admite hilos verdes a través de corrutinas
- Ruby antes de la versión 1.9 [23]
- Raqueta (los hilos nativos también están disponibles a través de Places [24] )
- Rust admite hilos 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 ). [25]
- Tcl tiene corrutinas y un bucle de eventos [26]
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 [ aclaración necesaria ] de los hilos verdes estándar. [ cita requerida ]
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. [ cita requerida ]
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 :
[ [( Retraso de milisegundos: 50 ) esperar ] repetir ] 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
- Asíncrono / espera
- Proceso ligero
- Corutina
- Máquina virtual de Java
- Bloqueo de intérprete global
- Fibra (informática)
- Hilos portátiles GNU
- Protothreads
Referencias
- ↑ a b Sintes, Tony (13 de abril de 2001). "Cuatro para las edades" . JavaWorld . Consultado el 14 de julio de 2020 .
Los subprocesos verdes, los subprocesos proporcionados por la JVM, se ejecutan a nivel de usuario, lo que significa que la JVM crea y programa los subprocesos en sí. Por lo tanto, el kernel del sistema operativo no los crea ni los programa. En cambio, el sistema operativo subyacente ve la JVM solo como un subproceso. Los hilos verdes resultan ineficaces por varias razones. En primer lugar, los subprocesos verdes no pueden aprovechar un sistema multiprocesador (...) Por lo tanto, los subprocesos de JVM están obligados a ejecutarse dentro de ese único subproceso de JVM que se ejecuta dentro de un solo procesador.
- ^ "Tecnología Java: los primeros años" . java.sun.com . 2014-12-22. Archivado desde el original el 30 de mayo de 2008.
- ^ "¿Cuál es la diferencia entre los hilos" verdes "y los hilos" nativos "?" . jguru.com . 2000-09-06 . Consultado el 1 de junio de 2009 .
En máquinas con varias CPU, los subprocesos nativos pueden ejecutar más de un subproceso simultáneamente al asignar diferentes subprocesos a diferentes CPU. Los hilos verdes se ejecutan en una sola CPU.
- ^ "Evaluación comparativa del rendimiento de subprocesos Java para aplicaciones embebidas: Linux Thread vs. Green Thread". CiteSeerX 10.1.1.8.9238 . Cite journal requiere
|journal=
( ayuda ) - ^ Stallings, William (2008). Sistemas operativos, principios internos y de diseño . Nueva Jersey: Prentice Hall. pag. 171. ISBN 9780136006329.
- ^ Sieger, Nick (22 de julio de 2011). "Concurrencia en JRuby" . Patio de motores . Consultado el 26 de enero de 2013 .
Para sistemas con grandes volúmenes de correo electrónico, este enfoque ingenuo puede no funcionar bien. Los subprocesos nativos tienen un costo de inicialización y una sobrecarga de memoria mayores que los subprocesos verdes, por lo que JRuby normalmente no puede admitir más de aproximadamente 10,000 subprocesos. Para solucionar esto, podemos usar un grupo de subprocesos.
- ^ Goetz, Brian (18 de octubre de 2005). "Teoría y práctica de Java: Optimizaciones de sincronización en Mustang" . IBM . Consultado el 26 de enero de 2013 .
- ^ "Java Threads en el entorno Solaris - versiones anteriores" . Oracle Corporation . Consultado el 26 de enero de 2013 .
Como resultado, surgieron varios problemas: las aplicaciones Java no podían interoperar con las aplicaciones MT existentes en el entorno Solaris, los subprocesos Java no podían ejecutarse en paralelo en multiprocesadores, una aplicación Java MT no podía aprovechar la verdadera concurrencia del sistema operativo para aplicaciones más rápidas en monoprocesadores o multiprocesadores . Para aumentar sustancialmente el rendimiento de las aplicaciones, la biblioteca de subprocesos ecológicos se reemplazó por subprocesos nativos de Solaris para Java en la plataforma Solaris 2.6; esto se lleva a cabo en las plataformas Solaris 7 y Solaris 8.
- ^ "Hilos: Verde o Nativo" . Grupo SCO . Consultado el 26 de enero de 2013 .
El beneficio de rendimiento del uso de subprocesos nativos en una máquina MP puede ser espectacular. Por ejemplo, si se utiliza un punto de referencia artificial en el que los subprocesos de Java realizan el procesamiento de forma independiente entre sí, puede haber una mejora de tres veces la velocidad general en una máquina MP de 4 CPU.
- ^ "Hilos: Verde o Nativo" . codestyle.org. Archivado desde el original el 16 de enero de 2013 . Consultado el 26 de enero de 2013 .
Existe una sobrecarga de procesamiento significativa para la JVM para realizar un seguimiento de los estados de los hilos y cambiar entre ellos, por lo que el modo de hilo verde ha quedado obsoleto y se ha eliminado de las implementaciones de Java más recientes.
- ^ "kilim" . GitHub . Consultado el 9 de junio de 2016 .
- ^ "Kilim" . www.malhar.net . Consultado el 9 de junio de 2016 .
- ^ "Código de Quasar en GitHub" .
- ^ "Universo Paralelo" . Consultado el 6 de diciembre de 2015 .
- ^ "Plan de pollo" . Consultado el 5 de noviembre de 2017 .
- ^ "thezerobit / green-threads" . GitHub . Consultado el 8 de abril de 2016 .
- ^ "Características de Stackless a nivel de aplicación - Documentación de PyPy 4.0.0" . Consultado el 6 de diciembre de 2015 .
- ^ "Simultaneidad: GitBook" . crystal-lang.org . Consultado el 3 de abril de 2018 .
- ^ "Hilos: Resumen" . Ayuda de Dyalog APL 17.0 . Consultado el 14 de diciembre de 2018 .
Un hilo es una hebra de ejecución en el espacio de trabajo de APL.
- ^ https://twitter.com/joeerl/status/1010485913393254401
- ^ a b "Ve y Dogma" . investigación! rsc . Consultado el 14 de enero de 2017 .
por ejemplo, tanto Go como Haskell necesitan algún tipo de "hilos verdes", por lo que hay más desafíos de tiempo de ejecución compartidos de los que cabría esperar.
- ^ "El lenguaje de programación del Limbo" . www.vitanuova.com . Consultado el 1 de abril de 2019 .
- ^ "Multithreading en el MRI Ruby Interpreter ~ BugFactory" . Consultado el 8 de junio de 2019 .
- ^ "Lugares de raqueta" . Consultado el 13 de octubre de 2011 .
Los lugares permiten el desarrollo de programas paralelos que aprovechan las máquinas con múltiples procesadores, núcleos o subprocesos de hardware. Un lugar es una tarea paralela que es efectivamente una instancia separada de la máquina virtual Racket.
- ^ "Stackless.com: Acerca de Stackless" . Archivado desde el original el 6 de febrero de 2013 . Consultado el 27 de agosto de 2008 .
Se incluye un programador por turnos. Se puede utilizar para programar tareas de forma cooperativa o preventiva.
- ^ "Bucle de eventos Tcl" . Consultado el 6 de diciembre de 2015 .
enlaces externos
- " Cuatro para todas las edades ", artículo de JavaWorld sobre hilos verdes
- Preguntas frecuentes sobre hilos verdes en hilos Java