Goroutines de concurrencia

Goroutines, canales y herramientas de sincronización. Los resultados aparecen en la misma valla: comentarios // en la misma línea cuando son cortos, bloques // multilínea debajo de la muestra cuando no lo son.

Palabra clave go

Inicia una goroutine.

done := make(chan struct{})
go func() { close(done) }()
<-done  // recibido

chan Envío Recepción

No amortiguado sincroniza el emisor y el receptor.

ch := make(chan int)
go func() { ch <- 7 }()
<-ch  // 7

Canal con búfer

Envía hasta que el búfer esté lleno.

ch := make(chan int, 1)
ch <- 1
<-ch  // 1

select

Espera en múltiples operaciones de canal.

ch := make(chan int, 1)
ch <- 2
select {
case v := <-ch:
    v  // 2
default:
    // ruta no bloqueante
}

WaitGroup

Espera un conjunto de goroutines.

var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done() }()
wg.Wait()
// todo hecho

Mutex

Protege la memoria compartida.

var mu sync.Mutex
var n int
mu.Lock()
n++
mu.Unlock()
n  // 1

RWMutex

Muchos lectores o un escritor.

var mu sync.RWMutex
mu.RLock()
// leer
mu.RUnlock()

Cerrar canal

Señaliza que no hay más envíos; range sale.

ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch)
sum := 0
for v := range ch { sum += v }
sum  // 3

select Default

Intento no bloqueante.

ch := make(chan int)
select {
case <-ch:
default:
    // ningún valor listo
}

Once

Ejecuta la inicialización exactamente una vez.

var once sync.Once
n := 0
once.Do(func() { n = 1 })
once.Do(func() { n = 2 })
n  // 1

Atómico

Contadores sin bloqueo.

var n atomic.Int64
n.Add(1)
n.Load()  // 1

Pipeline

Etapas de canales para procesar trabajo en streaming.

// entrada -> trabajador -> salida
// cada etapa es una goroutine que itera sobre la entrada

errgroup

Espera + primer error (golang.org/x/sync/errgroup).

// g, ctx := errgroup.WithContext(ctx)
// g.Go(func() error { ... })
// return g.Wait()

Cancelar contexto de trabajadores

Escucha en ctx.Done() en los trabajadores.

// select { case <-ctx.Done(): return ctx.Err(); case ch <- v: }

Selección de canal nulo

Los casos de canal nulo se ignoran en select.

var ch chan int  // nulo
select {
case <-ch:
default:
    // se toma el default; el canal nulo nunca está listo
}

Relacionado

• Paquete Contexto - cancelar trabajo concurrente
• Manejo de errores - errores de los trabajadores
• Conceptos básicos de Net HTTP - concurrencia de solicitudes

Enlaces externos relacionados

• Effective Go - Guía oficial para escribir Go claro e idiomático.
• Go by Example - Ejemplos de código prácticos anotados.
• Documentación de la biblioteca estándar de Go - Referencia completa de la biblioteca estándar.
• Concurrency in Go - Katherine Cox-Buday.
• Learning Go (2nd Edition) - Jon Bodner.

Versiones de la pila: Go 1.26.x · chi/gin/echo más reciente (verificar en la compilación)