Golang Waitgroup

Golang Waitgroup
📋 Aquí podrás encontrar✍
  1. Introducción
  2. Qué es la WaitGroup
  3. Cómo usar WaitGroup en GoLang
  4. Ejemplos de uso
  5. Conclusión
  6. Preguntas frecuentes
    1. ¿Puedo llamar a `Done()` varias veces?
    2. ¿Qué sucede si llamo a `Wait()` antes de llamar a `Add()`?
    3. ¿Qué sucede si llamo a `Done()` antes de llamar a `Add()`?
    4. ¿La WaitGroup es segura para concurrencia?

Introducción

La Go WaitGroup es una herramienta muy útil en GoLang para esperar a que finalicen todas las goroutines antes de continuar con la ejecución del programa. Esto permite asegurarnos de que todo el trabajo realizado en las diferentes goroutines ha finalizado antes de finalizar el programa principal.

Qué es la WaitGroup

La WaitGroup es una estructura que mantiene un contador de goroutines. El contador se incrementa mediante la llamada a `Add` y se decrementa cuando cada goroutine finaliza su trabajo llamando a `Done`. El método `Wait` bloquea la ejecución hasta que el contador alcance el valor cero. Esto indica que todas las goroutines han terminado su trabajo.

Cómo usar WaitGroup en GoLang

Para usar la WaitGroup en GoLang, primero necesitamos crear una instancia de ella:


var wg sync.WaitGroup

Luego, dentro de la función que queremos ejecutar en una goroutine, debemos llamar a `Add(1)` al principio y a `Done()` al final:


func miFuncion(wg *sync.WaitGroup) {
defer wg.Done()
// código a ejecutar en la goroutine
}

func main() {
wg.Add(1)
go miFuncion(&wg)
wg.Wait()
// resto del código
}

El método `Add(1)` indica que se ha creado una goroutine y el método `Wait()` bloquea hasta que todas las goroutines llamadas tengan su correspondiente `Done()`.

Ejemplos de uso

Un ejemplo práctico de usar la WaitGroup podría ser la creación de un servidor web que depende de múltiples goroutines para servir solicitudes. En lugar de terminar inmediatamente después de lanzar la combinación de goroutines, podemos usar la WaitGroup para esperar a que todos los procesos finalicen antes de finalizar la ejecución del programa.


package main

import (
"fmt"
"net/http"
"sync"
)

func servidorWeb(wg *sync.WaitGroup) {
defer wg.Done()
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "¡Hola, mundo!")
})
http.ListenAndServe(":8080", nil)
}

func main() {
var wg sync.WaitGroup
wg.Add(1)
go servidorWeb(&wg)
wg.Wait()
}

En este ejemplo, la función `servidorWeb` inicia un servidor web que responde "¡Hola, mundo!" en la dirección raíz. Al llamar a `ListenAndServe`, el programa entra en un bucle infinito para esperar solicitudes del cliente. En `main`, se llama a `Add(1)` y se inicia la goroutine para iniciar el servidor web. Luego, se llama a `Wait()` para que el programa no finalice hasta que `servidorWeb` llame a `Done()`.

Conclusión

La WaitGroup es una herramienta poderosa para garantizar que todas las goroutines se hayan completado antes de finalizar la ejecución del programa. En GoLang, es fácil de usar y garantiza que las goroutines terminen correctamente antes de que finalice el programa.

Preguntas frecuentes

¿Puedo llamar a `Done()` varias veces?

No. El método `Done()` solo debe llamarse una vez por goroutine. Si necesitas que se llame varias veces, deberás crear varias instancias de WaitGroup.

¿Qué sucede si llamo a `Wait()` antes de llamar a `Add()`?

El programa se bloqueará en la llamada `Wait()`, ya que la WaitGroup todavía tiene un contador de goroutines establecido en cero.

¿Qué sucede si llamo a `Done()` antes de llamar a `Add()`?

No habrá ningún efecto en el contador de goroutines. Se recomienda llamar primero a `Add()` antes de llamar a `Done()`.

¿La WaitGroup es segura para concurrencia?

Sí. La WaitGroup se puede utilizar de forma segura en múltiples goroutines al mismo tiempo.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir