GoLang (Go) es un lenguaje de programación conocido por su concurrencia y eficiencia. ¿Y cómo proporciona un soporte tan rico para la concurrencia? Via Goroutines.
Los goroutines son, como podemos comparar, hilos ligeros que ejecutan más de una tarea simultáneamente. Este artículo trata sobre por qué usamos Goroutines y cómo los usamos. Antes de ir a Goroutines necesitamos ver qué es la concurrencia.
Go usa goroutines mientras que un lenguaje como Java usa hilos. Go nos permite escribir programas concurrentes. Proporciona goroutines y, lo que es más importante, la capacidad de comunicarse entre ellos.
Goroutines e hilos – las diferencias
- ¿Cuáles son los mejores recursos en línea para aprender varios lenguajes de programación?
- ¿Cuáles son algunos recursos en línea para prepararse para AP Computer Science?
- ¿Dónde puedo aprender las técnicas específicas utilizadas para los jeans y denim envejecidos y angustiantes?
- ¿Cuál es la mejor manera de aprender el análisis de datos para un principiante?
- ¿Cuáles son algunos buenos recursos (libros, blogs, etc.) para las pautas de internacionalización y localización?
Go usa goroutines mientras que un lenguaje como Java usa hilos. ¿Cuáles son las diferencias entre los dos? Necesitamos considerar 3 factores: el consumo de memoria, la configuración y el tiempo de desmontaje y cambio.
Consumo de memoria
La creación de un goroutine no requiere mucha memoria, solo 2kB de espacio de pila. Crecen al asignar y liberar almacenamiento de almacenamiento dinámico según sea necesario.
[2] [3]
Por otro lado, los hilos comienzan a 1Mb (500 veces más), junto con una región de la memoria llamada página de protección que actúa como una protección entre la memoria de un hilo y la otra.
Por lo tanto, un servidor que maneja solicitudes entrantes puede crear una goroutine por solicitud sin problemas, pero un hilo por solicitud eventualmente llevará a la temida OutOfMemoryError. Esto no se limita a Java: cualquier lenguaje que use subprocesos del sistema operativo como el principal medio de concurrencia enfrentará este problema.
Costos de instalación y desmontaje
Los subprocesos tienen costos de instalación y desmontaje significativos porque tiene que solicitar recursos del sistema operativo y devolverlos una vez que se haya completado. La solución a este problema es mantener un grupo de subprocesos. En contraste, los goroutines son creados y destruidos por el tiempo de ejecución y esas operaciones son bastante baratas. El lenguaje no admite la gestión manual de goroutines.
Costo de cambio
Cuando un hilo se bloquea, otro tiene que ser programado en su lugar. Los subprocesos se programan de forma preventiva y, durante un cambio de subproceso, el programador debe guardar / restaurar TODOS los registros, es decir, 16 registros de propósito general, PC (contador de programas), SP (puntero de pila), registros de segmento, 16 registros XMM, coprocesador FP estado, 16 registros AVX, todos los MSR, etc. Esto es bastante significativo cuando hay un cambio rápido entre subprocesos.
Las goroutinas se programan de forma cooperativa y, cuando se produce un cambio, solo se deben guardar / restaurar 3 registros: el contador del programa, el puntero de pila y el DX. El costo es mucho menor.
Como se mencionó anteriormente, el número de goroutines es generalmente mucho mayor, pero eso no hace una diferencia para cambiar el tiempo por dos razones. Solo se consideran los goroutines ejecutables, los bloqueados no. Además, los programadores modernos tienen una complejidad O (1), lo que significa que el tiempo de cambio no se ve afectado por el número de opciones (subprocesos o goroutines).
Cómo se ejecutan los goroutines.
Como se mencionó anteriormente, el tiempo de ejecución administra los goroutines desde la creación hasta la programación y el desmontaje. Al tiempo de ejecución se le asignan algunos subprocesos en los que se multiplexan todos los goroutines. En cualquier momento, cada subproceso ejecutará una goroutina. Si ese goroutine está bloqueado, entonces se cambiará por otro goroutine que se ejecutará en ese hilo en su lugar.
Como los goroutines están programados de forma cooperativa, un goroutine que se repite continuamente puede matar a otros goroutines en el mismo hilo. En Go 1.2, este problema se alivia de alguna manera invocando ocasionalmente al programador Go al ingresar a una función, por lo que se puede anular un ciclo que incluye una llamada de función no integrada.
Recurso de video: –
Recursos útiles:
Goroutines para la concurrencia – Agira Technologies
Concurrencia – Una Introducción a la Programación en Go
Goroutines – Concurrencia en Golang
Vamos por ejemplo: Goroutines