Canales: Reglas de Búfer, Sin Búfer y Cierre

Los canales transportan valores y sincronización entre goroutines.

Elegir la capacidad con búfer o sin búfer y seguir las reglas de propiedad de cierre evita bloqueos y pánicos en los pipelines de producción.

Resumen

Un canal sin búfer sincroniza a los compañeros: el remitente se bloquea hasta que el receptor está listo.

Un canal con búfer almacena hasta cap valores sin un receptor esperando.

Cerrar un canal transmite "no más envíos" a los receptores; solo los remitentes deben cerrar.

range sobre un canal lo vacía hasta que se cierra; la recepción de dos valores v, ok := <-ch detecta el cierre explícitamente.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

package main
 
import "fmt"
 
func main() {
    ch := make(chan int, 2) // con búfer
    ch <- 1
    ch <- 2
    close(ch)
 
    for v := range ch {
        fmt.Println(v)
    }
 
    v, ok := <-ch
    fmt.Println(v, ok) // 0 false después de vaciar el cierre
}

Cuándo usar esto:

• Sin búfer: traspaso, acuse de recibo, presión de retroceso estricta entre etapas.
• Con búfer: suaviza ráfagas cuando el productor y el consumidor se ejecutan a diferentes velocidades.
• Cierre: productor terminado; los consumidores deben salir de los bucles range.
• Nunca cierres desde el lado del receptor en pipelines compartidos.

Ejemplo de Trabajo

package main
 
import (
    "fmt"
    "sync"
)
 
func producer(out chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 1; i <= 5; i++ {
        out <- i
    }
    close(out) // el remitente cierra
}
 
func consumer(in <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for v := range in {
        fmt.Println("got", v)
    }
}
 
func main() {
    ch := make(chan int) // sin búfer - traspaso de sincronización
    var wg sync.WaitGroup
    wg.Add(2)
    go producer(ch, &wg)
    go consumer(ch, &wg)
    wg.Wait()
}

Lo que esto demuestra:

• Los tipos direccionales chan<- y <-chan documentan el uso de solo envío/solo recepción.
• El remitente cierra después del último envío para que range en el consumidor termine.
• El canal sin búfer acopla los tiempos del productor y el consumidor.
• WaitGroup espera a que ambos lados terminen.

Inmersión Profunda

Cómo Funciona

• El envío de canal copia el valor en el búfer del canal o lo entrega directamente (sin búfer).
• La recepción copia y libera una ranura del búfer o desbloquea un remitente.
• close(ch) establece la bandera de cerrado; los envíos futuros obtienen el valor cero con ok == false.
• Enviar en un canal cerrado provoca un pánico; recibir de un canal cerrado es seguro (devuelve cero).
• len(ch) y cap(ch) informan sobre los elementos en cola y la capacidad.

Con Búfer vs Sin Búfer

Reglas de Cierre

Notas de Go

// Fan-in: una goroutine cierra después de que todos los remitentes terminan
func fanIn(inputs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(inputs))
    for _, in := range inputs {
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                out <- v
            }
        }(in)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

Trampas

• Enviar en un canal cerrado - Pánico. Solución: solo el remitente cierra; usa sync.Once para proteger el cierre.
• Fuga: receptor desaparecido, remitente bloqueado - El envío sin búfer espera para siempre. Solución: cancelar context, select con tiempo de espera o búfer.
• Range sin cierre - El consumidor se bloquea para siempre. Solución: el remitente debe close o cancelar upstream.
• Cerrar el canal orientado al consumidor mientras se envía - Carrera con envíos en curso. Solución: cerrar solo después de que todos los envíos se completen (a menudo WaitGroup y luego cerrar).
• Búfer enorme que enmascara la sobrecarga - La memoria crece, la latencia se oculta. Solución: dimensionar según el SLA; descargar carga cuando esté lleno.

49454e4f4d5f434e4f5904434556494d43451e1f1c56181a181c1a1d

Alternativas

Preguntas Frecuentes

Relacionado

• Fundamentos de Concurrencia - primeros ejemplos de canales
• Sentencia select y Casos Predeterminados - multiplexación de recepciones
• Concurrencia en Go: Goroutines y Canales Primero - descripción general de CSP
• sync.Mutex, RWMutex y WaitGroup - alternativa de estado compartido
• Fundamentos de Concurrencia Mejores Prácticas - hábitos de canales

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC Green Tea, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).