Go Concurrencia

La concurrencia es la capacidad de un programa para ejecutar múltiples tareas al mismo tiempo.

El lenguaje Go admite concurrencia y, a través de goroutines y channels, ofrece una forma sencilla y eficiente de implementarla.

Goroutines:

  • Unidad de ejecución concurrente en Go, similar a un hilo ligero.
  • La programación de las goroutines es gestionada por el runtime de Go; el usuario no necesita asignar hilos manualmente.
  • Usogode la palabra clave para iniciar una goroutine.
  • Las goroutines no son bloqueantes y pueden ejecutar eficientemente decenas de miles de goroutines.

Channel:

  • Mecanismo en Go para comunicarse entre goroutines.
  • Admite sincronización y compartición de datos, evitando mecanismos de bloqueo explícitos.
  • Usochande la palabra clave para crear, mediante<-el operador para enviar y recibir datos.

Planificador (Scheduler):

El planificador de Go se basa en el modelo GMP: asigna las goroutines a los hilos del sistema para ejecutarlas y gestiona eficientemente la concurrencia mediante la cooperación de M y P.

  • G:Goroutine。
  • MM: hilo del sistema (Machine).
  • PP: procesador lógico (Processor).

Goroutine

Una goroutine es un hilo ligero; la programación de las goroutines es gestionada por el runtime de Golang.

Formato de sintaxis de goroutine:

go 函数名( 参数列表 )

Por ejemplo:

go f(x, y, z)

Iniciar una nueva goroutine:

f(x, y, z)

Go permite usar la sentencia go para iniciar un nuevo hilo en tiempo de ejecución, es decir, una goroutine, para ejecutar una función en una goroutine distinta y recién creada. Todas las goroutines en el mismo programa comparten el mismo espacio de direcciones.

Ejemplo

package main

import (
        "fmt"
        "time"
)

func sayHello() {
        for i := 0; i < 5; i++ {
                fmt.Println("Hello")
                time.Sleep(100 * time.Millisecond)
        }
}

func main() {
        go sayHello() // Iniciar goroutine
        for i := 0; i < 5; i++ {
                fmt.Println("Main")
                time.Sleep(100 * time.Millisecond)
        }
}

Al ejecutar el código anterior, verás las salidas Main y Hello. La salida no tiene un orden fijo porque son dos goroutines las que se ejecutan:

Main
Hello
Main
Hello
...

Canal (Channel)

Un canal (Channel) se utiliza para la transferencia de datos entre goroutines.

Un canal se puede usar entre dos goroutines para sincronizar la ejecución y comunicarse mediante el paso de un valor de un tipo específico.

Usomakede la función para crear un canal, usando<-el operador para enviar y recibir datos.

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

Declarar un canal es muy sencillo, solo usamos la palabra clave chan; el canal debe crearse antes de usarse:

ch := make(chan int)

Nota: de forma predeterminada, el canal no tiene búfer. El extremo emisor envía datos y, al mismo tiempo, debe haber un extremo receptor que los reciba.

El siguiente ejemplo usa dos goroutines para calcular la suma de números; después de que las goroutines completan el cálculo, se calcula la suma de los dos resultados:

Ejemplo

package main

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // Envía sum al canal c
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // Recibir del canal c

    fmt.Println(x, y, x+y)
}

El resultado de la salida es:

-5 17 12

Búfer del canal

El canal puede configurar un búfer; el tamaño del búfer se especifica mediante el segundo parámetro de make:

ch := make(chan int, 100)

Un canal con búfer permite que el envío de datos del extremo emisor y la obtención de datos del extremo receptor estén en un estado asíncrono; es decir, los datos enviados por el emisor pueden colocarse en el búfer y esperar a que el receptor los obtenga, en lugar de requerir que el receptor los obtenga inmediatamente.

Sin embargo, dado que el tamaño del búfer es limitado, aún debe haber un receptor para recibir los datos; de lo contrario, cuando el búfer esté lleno, el extremo emisor no podrá enviar más datos.

Nota: si el canal no tiene búfer, el emisor se bloquea hasta que el receptor recibe un valor del canal. Si el canal tiene búfer, el emisor se bloquea hasta que el valor enviado se copia en el búfer; si el búfer está lleno, significa que debe esperar hasta que algún receptor obtenga un valor. El receptor se bloquea hasta que haya un valor disponible para recibir.

Ejemplo

package main

import "fmt"

func main() {
    // Aquí definimos un canal con búfer que puede almacenar enteros
    // El tamaño del búfer es 2
    ch := make(chan int, 2)

    // Como ch es un canal con búfer, podemos enviar dos datos al mismo tiempo
    // sin necesidad de leer los datos sincrónicamente de inmediato
    ch <- 1
    ch <- 2

    // Obtener estos dos datos
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

El resultado de la ejecución es:

1
2

Go: iterar canales y cerrar canales

Go usa la palabra clave range para iterar sobre los datos recibidos, de manera similar a los arrays o slices. El formato es el siguiente:

v, ok := <-ch

Si el canal no recibe datos, ok pasa a ser false; entonces se puede usarclose()la función para cerrar.

Ejemplo

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    // La función range itera sobre cada dato recibido del canal, ya que c, después de enviar 10
    // datos, cierra el canal, por lo que aquí la función range, después de recibir 10 datos,
    // termina. Si el canal c anterior no se cerrara, la función range no
    // terminaría, y se bloquearía al recibir el undécimo dato.
    for i := range c {
        fmt.Println(i)
    }
}

El resultado de la ejecución es:

0
1
1
2
3
5
8
13
21
34

Sentencia Select

selectLa sentencia select permite que una goroutine espere múltiples operaciones de comunicación.selectSe bloqueará hasta que uno de los casos pueda continuar ejecutándose:

Ejemplo

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)

    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

En el código anterior,fibonaccila goroutine, en el canalcenvía la sucesión de Fibonacci; cuando recibequitla señal del canal, termina.

El resultado de la ejecución es:

0
1
1
2
3
5
8
13
21
34
quit

Uso de WaitGroup

sync.WaitGroup se utiliza para esperar a que varias goroutines terminen.

Sincronizar varias goroutines:

Ejemplo

package main

import (
        "fmt"
        "sync"
)

func worker(id int, wg *sync.WaitGroup) {
        defer wg.Done() // Llamar a Done() cuando la goroutine termina
        fmt.Printf("Worker %d started\n", id)
        fmt.Printf("Worker %d finished\n", id)
}

func main() {
        var wg sync.WaitGroup

        for i := 1; i <= 3; i++ {
                wg.Add(1) // Incrementar el contador
                go worker(i, &wg)
        }

        wg.Wait() // Esperar a que todas las goroutines terminen
        fmt.Println("All workers done")
}

El resultado de ejecutar el código anterior es el siguiente:

Worker 1 started
Worker 1 finished
Worker 2 started
Worker 2 finished
Worker 3 started
Worker 3 finished
All workers done

Características avanzadas

Buffered Channel:

Crear un canal con búfer.

ch := make(chan int, 2)

Context:

Se utiliza para controlar el ciclo de vida de las goroutines.

context.WithCancel、context.WithTimeout。

Mutex y RWMutex:

sync.Mutex proporciona un bloqueo mutex para proteger recursos compartidos.

var mu sync.Mutex
mu.Lock()
// critical section
mu.Unlock()

Resumen de programación concurrente

El lenguaje Go proporciona un potente soporte de concurrencia a través de Goroutines y Channels, simplificando la complejidad del modelo tradicional de hilos. Junto con el planificador y las herramientas de sincronización, se pueden implementar fácilmente programas concurrentes de alto rendimiento.

  • Goroutineses un hilo ligero; usegola palabra clave para iniciarla.
  • ChannelsSe utiliza para la comunicación entre goroutines.
  • Sentencia SelectSe utiliza para esperar múltiples operaciones de canal.

Preguntas frecuentes

Punto muerto (Deadlock):

  • Ejemplo: todas las goroutines están esperando, pero no hay datos disponibles.
  • Solución: evitar esperas indefinidas y cerrar los canales correctamente.

Condición de carrera (Data Race):

  • Ejemplo: varias goroutines acceden a la misma variable al mismo tiempo.
  • Solución: usar Mutex o Channel para sincronizar el acceso.
Otras extensiones