¿Cuáles son los patrones comunes de concurrencia en Go?

Question

Accepted Answer

Las goroutines y los canales de Go permiten un conjunto de **patrones de concurrencia** bien establecidos que resuelven problemas comunes — distribución de trabajo, fan-out/in, pipelines y rate limiting. Conocer estos patrones idiomáticos te permite construir sistemas concurrentes correctos y eficientes.

## Pool de workers — concurrencia acotada

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // a FIXED number of workers
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // each worker pulls jobs until the channel closes
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

Un **pool de workers** ejecuta un número fijo de goroutines que consumen de un canal de tareas compartido — acotando la concurrencia (p. ej., no abras 10,000 conexiones a DB; usa 10 workers). Este es el patrón más importante para controlar el uso de recursos.

## Fan-out / fan-in

```text
Fan-out: distribute work across MULTIPLE goroutines (parallelize)
Fan-in:  MERGE results from multiple goroutines back into one channel
```

```go
// fan-in: merge several channels into one
func merge(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c { out <- v }   // forward each channel's values to out
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // close out when all sources are drained
    return out
}
```

## Pipeline — etapas conectadas por canales

```go
// each stage is a goroutine: receives from an input channel, sends to an output channel
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}
// compose: square(generate(1,2,3)) → a streaming pipeline
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

Un **pipeline** encadena etapas de procesamiento a través de canales — los datos fluyen, y cada etapa los transforma concurrentemente.

## Rate limiting

```go
limiter := time.Tick(200 * time.Millisecond)   // a tick every 200ms
for req := range requests {
    <-limiter                                    // wait for the next tick before proceeding
    go handle(req)                                // → at most 5 requests/second
}
```

## Cancelación con context (transversal)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // stop on cancellation — prevents leaks
}
```

## Por qué es importante

Estos patrones de concurrencia son el kit de herramientas práctico para construir sistemas Go concurrentes reales, convirtiendo goroutines y canales sin procesar en soluciones estructuradas y correctas para problemas recurrentes.

El **pool de workers** es especialmente importante — acota la concurrencia para proteger recursos limitados (conexiones a bases de datos, límites de velocidad de API, memoria), previniendo el error común de generar goroutines ilimitadas que agotan el sistema. **Fan-out/fan-in** paraleliza el trabajo y fusiona resultados; **pipelines** modelan transformaciones de datos en streaming de forma clara; **rate limiting** controla el rendimiento.

Combinados con **cancelación basada en context** (para evitar fugas de goroutines), estos patrones son cómo los servicios Go en producción manejan la concurrencia de forma segura y eficiente.

Comprenderlos — y especialmente saber acotar la concurrencia con pools de workers en lugar de lanzar goroutines ilimitadas — es un distintivo de competencia avanzada en Go y un tema frecuente en entrevistas avanzadas, ya que la concurrencia ingenua (goroutines ilimitadas, fugas, condiciones de carrera) es una fuente común de fallos en producción.