Golang Waitgroup

📋 Aquí podrás encontrar✍

Introducción
Qué es la WaitGroup
Cómo usar WaitGroup en GoLang
Ejemplos de uso
Conclusión
Preguntas frecuentes

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.