Hilos y multitarea en Go

Una de las cosas más llamativas de Go es la facilidad con que se aprovecha de forma nativa la multitarea, en la programación el procesamiento en hilos es la capacidad del lenguaje para ejecutar múltiples procesos o subprocesos a la vez en paralelo. En una aplicación multiproceso, los procesos y los hilos comparten los recursos de uno o varios núcleos.

Ejecución normal

package main

import "fmt"

func main() {
    
    for i := 0; i < 20; i++ {
        thread(i)
    }
}

func thread(index int) {
    fmt.Println("Este es el hilo número", index)
}

Vemos que la salida es ordenada, cada ejecución de la función se hace en orden ascendente.

Este es el hilo número 0
Este es el hilo número 1
Este es el hilo número 2
Este es el hilo número 3
Este es el hilo número 4
Este es el hilo número 5
Este es el hilo número 6
Este es el hilo número 7
Este es el hilo número 8
Este es el hilo número 9
Este es el hilo número 10
Este es el hilo número 11
Este es el hilo número 12
Este es el hilo número 13
Este es el hilo número 14
Este es el hilo número 15
Este es el hilo número 16
Este es el hilo número 17
Este es el hilo número 18
Este es el hilo número 19

Ejecución en Hilos

Vamos a hacer algunos cambios en el código, comenzando por la función thread en la que vamos a generar un número aleatorio de segundos para simular una carga de trabajo en la función thread y que así no terminen al mismo tiempo y en orden.

Un detalle muy importante es que cuando se lance un thread el hilo principal continuará con su ejecución, si el programa principal llega al final no esperará a que cada uno de los hilos hijos termine sino que los abortara a todos.

Para crear los hilos de la función thread vamos ha hacer uso de la función nativa go creando 20 hilos.

package main

import "fmt"
import "time"
import "math/rand"

func main() {
    
    //Creamos 20 hilos de la función
    for i := 0; i < 20; i++ {
        go thread(i)
    }

    //Este tiempo es importante debido a que si el hilo
    //principal termina antes, los hilos no se 
    //ejecutarán
    time.Sleep(101 * time.Second);
}


func thread(index int) {

    //Para simular una carga de trabajo
    //dormimos el programa x cantidad de segundo
    //donde x puede ir de x a 100
    var seconds int
    seconds = rand.Intn(100)
    time.Sleep(time.Duration(seconds) * time.Second)

    fmt.Println("Este es el hilo número", index,"(",seconds,"s )")
}

Ahora con estas modificaciones vemos que cada hilo terminó en una cantidad de segundos determinada.

El primer hilo lanzado fue el 1, el segundo el 2 y así sucesivamente sin embargo el primero en terminar fue el hilo 10 que demoró 0s y el segundo el 16 que demoró 6 segundos.

En otras palabras uno fue lanzado correlativamente sin embargo cada uno tenía una duración diferente, y fueron terminando de acuerdo a su duración y no al orden en que fueron lanzados ya que corrieron de forma paralela.

Este es el hilo número 10 ( 0 s )
Este es el hilo número 16 ( 6 s )
Este es el hilo número 11 ( 11 s )
Este es el hilo número 17 ( 11 s )
Este es el hilo número 6 ( 18 s )
Este es el hilo número 7 ( 25 s )
Este es el hilo número 14 ( 28 s )
Este es el hilo número 19 ( 37 s )
Este es el hilo número 8 ( 40 s )
Este es el hilo número 18 ( 45 s )
Este es el hilo número 0 ( 47 s )
Este es el hilo número 9 ( 56 s )
Este es el hilo número 4 ( 59 s )
Este es el hilo número 12 ( 62 s )
Este es el hilo número 1 ( 74 s )
Este es el hilo número 2 ( 81 s )
Este es el hilo número 5 ( 81 s )
Este es el hilo número 3 ( 87 s )
Este es el hilo número 13 ( 89 s )
Este es el hilo número 15 ( 94 s )

Conclusión

Creo que en ningún otro lenguaje es tan facil la creacion de hilos para aprovechar la multitarea y utilizar todos los nucleos del CPU, hay lenguajes que permiten crear hilos aunque siempre en el mismo núcleo de la ejecución principal, con Go vamos a aprovechar todos los núcleos del sistema de una forma muy sencilla.