Conociendo las gorutinas en Go

Una de las mejores características de Go es que se trata de un lenguaje concurrente, gracias a que fue concebido en la era de los procesadores de múltiples núcleos su soporte para el trabajo con estos es nativo y realmente fácil de implementar

¿Qué es la concurrencia?

La concurrencia es una propiedad de los sistemas en la cual los procesos de un cómputo se hacen simultáneamente, y pueden interactuar entre ellos. Los cálculos (operaciones) pueden ser ejecutados en múltiples procesadores, o ejecutados en procesadores separados físicamente o virtualmente en distintos hilos de ejecución.
Fuente: Wikipedia

Goroutinas

Podemos definirlas como hilos ligeros que son administrados por Go en tiempo de ejecución. Si los hilos de ejecución tradicionales están limitados por la cantidad de núcleo disponibles y son administrados por el Sistema Operativo del equipo, múltiples Gorutinas pueden ejecutarse dentro de un mismo hilo, y estas son administradas eficientemente por el runtime de Go. Esto posiblemente no tenga demasiado significado para ustedes, así que lo mejor es verlas en acción.

package main

import (
    "fmt"
)

func saludar(nombres []string) {
    for _, nombre := range nombres {
        fmt.Printf("Hola %s\n", nombre)
    }
}

func despedir(nombres []string) {
    for _, nombre := range nombres {
        fmt.Printf("Adiós %s\n", nombre)
    }
}

func main() {
    nombres := []string{"Orlando", "Daniela", "José", "Carlos", "Andrea", "David", "Carmen"}
    go saludar(nombres)
    go despedir(nombres)
}

No hay mucho que explicar aquí, con excepción de cierta palabra reservada tan pequeña que es fácil de ignorar, go. Al colocar go antes de la llamada de la función le estamos diciendo que se ejecute de manera concurrente, es decir, en una gorutina, así de sencillo. Aunque tenemos un problema, al ejecutarlo el programa termina sin que veamos alguna salida por consola, la razón es que la función main termina antes de que se ejecuten saludar y despedir. Realicemos algunos cambios.

import (
    "fmt"
    "time"
)

func saludar(nombres []string) {
    for _, nombre := range nombres {
        fmt.Printf("Hola %s\n", nombre)
        time.Sleep(time.Millisecond * 500)
    }
}

func despedir(nombres []string) {
    for _, nombre := range nombres {
        fmt.Printf("Adiós %s\n", nombre)
        time.Sleep(time.Second)
    }
}

func main() {
    nombres := []string{"Orlando", "Daniela", "José", "Carlos", "Andrea", "David", "Carmen"}
    go saludar(nombres)
    go despedir(nombres)

    var s string
    fmt.Scan(&s)
}

Nos concentraremos en las diferencias, ahora estamos utilizando el paquete time de la biblioteca estándar de Go, con este paquete tenemos acceso a funcionalidades para medir y mostrar tiempo, pero explicar el paquete no es la razón de este artículo, si deseas saber más, recomiendo dirigirse a la documentación.

Gracias a la función Sleep del paquete time obligamos a cada iteración del ciclo a esperar el tiempo que pasemos como parámetros como un número entero, aunque por legibilidad hacemos uso de las unidades que provee el propio paquete time. Con esto será más fácil seguirle el paso a la ejecución de las gorutinas.

Al final de la función main podemos ver la instrucción fmt.Scan(&s), esta es una manera sencilla de leer entradas por consola, aunque para este ejemplo sólo nos interesa dejar en espera a la función main mientras se ejecutan las gorutinas. De esta forma podemos ver que ambas funciones se ejecutan simultáneamente.

Existen muchas manera de utilizar las gorurinas y Go nos provee de muchas herramientas interesantes para trabajar con ellas, les recomiendo investigar más al respecto. En futuras publicaciones exploraremos otras posibilidades y casos de uso.

Publicaciones relacionadas

1. De Python a Go (Golang)

2. Introducción al lenguaje de programación Go (Golang)

3. Estructuras de control de flujo en Go

4. Array y Slice en Go (Golang)

5. Maps en Go (Golang)

6. Punteros en Go (Golang)

7. Importaciones y paquetes en Go (Golang)

8. Paquetes de terceros y alias en Go (Golang)

9. Tipos de datos Personalizados y Métodos en Go (Golang)

10. Estructuras: ¿Las Clases de Go (Golang)?

11. Interfaces en Go (Golang)

12. Interfaces vacías en Go (Golang)

13. Manejo de errores en Go (Golang)

14. Conociendo Panic y Recover en Go (Golang)

Gracias por leer, espero que este artículo te resultara de provecho. Si así fue, no dudes en dejar un comentario, compartirlo y votar. Te invito a comentar cualquier duda o sugerencia, te aseguro que las leo todas. Así que, por favor, ayúdame a mejorar y continuar compartiendo contenido de calidad. Si te gusta la programación y/o la informática en general, te invito a formar parte de la comunidad Develop Spanish dónde compartimos contenido de esa naturaleza y totalmente en español. Hasta la próxima.