0Pricing
Go Academy · Lección

Patrones de pipelines y etapas

Composición de pipelines concurrentes de varias etapas

Patrones de pipelines y etapas es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Qué es un pipeline?

Un pipeline concurrente es una serie de etapas conectadas mediante canales. Cada etapa recibe valores de la anterior, los transforma y envía los resultados a la siguiente, lo que permite que las etapas se ejecuten de forma concurrente.

Pipeline sencillo de tres etapas

Generar → transformar → consumir:

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for _, n := range nums { out <- n } }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for n := range in { out <- n*n } }()
    return out
}

for v := range square(generate(2, 3, 4)) {
    fmt.Println(v) // 4, 9, 16
}

Patrón de etapas

Cada etapa es una función que recibe un canal de entrada y devuelve un canal de salida. Las etapas se componen fácilmente y pueden paralelizarse de forma independiente.

Fan-out dentro de un pipeline

Divida una etapa en N goroutines para paralelizar el trabajo limitado por la CPU:

func parallelSquare(in <-chan int, n int) <-chan int {
    outs := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        outs[i] = square(in) // all read from same in
    }
    return merge(outs...)
}

Cancelación con context

Pase un context a cada etapa. Cuando se cancela, las etapas dejan de leer y cierran sus canales de salida, vaciando todo el pipeline.

func stage(ctx context.Context, in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for {
            select {
            case v, ok := <-in:
                if !ok { return }
                select {
                case out <- process(v):
                case <-ctx.Done(): return
                }
            case <-ctx.Done(): return
            }
        }
    }()
    return out
}

Contrapresión

Utilice canales con búfer entre las etapas para desacoplar la velocidad del productor y la del consumidor. Sin búfer, una etapa lenta detiene todo el pipeline.

out := make(chan Result, 50) // buffer 50 results

Propagación de errores

Envuelva los valores en una estructura de resultado para propagar los errores por el pipeline sin provocar un panic:

type item struct { val int; err error }

Patrón del canal done

Utilice un canal done como alternativa a context en pipelines sencillos. Cierre done para indicar a todas las etapas que deben detenerse.

done := make(chan struct{})
defer close(done)

Garantías de orden

Un pipeline sencillo conserva el orden si cada etapa es secuencial. Las etapas paralelizadas no conservan el orden; utilice un campo de índice para volver a ordenar los resultados más adelante si es necesario.

Pipeline con WaitGroup

La última etapa no necesita cerrar un canal; basta con recorrerlo con range. Utilice WaitGroup en el fan-in para cerrar el canal combinado cuando terminen todas las goroutines productoras.

Uso en el mundo real

Aplicaciones habituales de los pipelines: procesamiento de datos ETL, redimensionamiento de imágenes, análisis de logs, sistemas de compilación y gestores de solicitudes en streaming.

Comprobación rápida

¿Cómo se propaga la cancelación por un pipeline de varias etapas?

Resumen: patrón de pipeline

Puntos clave:

  • Etapa: func(in <-chan T) <-chan U; composición para crear pipelines
  • Cancelación mediante context; contrapresión mediante canales con búfer
  • Fan-out dentro de una etapa para lograr paralelismo
  • Envuelva los valores en una estructura de resultado para propagar errores

Preguntas frecuentes

¿La lección «Patrones de pipelines y etapas» es gratis?

Sí — el texto completo de «Patrones de pipelines y etapas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Patrones de pipelines y etapas»?

Composición de pipelines concurrentes de varias etapas Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Patrones de pipelines y etapas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Patrones de pipelines y etapas
  2. errgroup para gestionar errores concurrentes
  3. Patrón de semáforo
  4. Detección de fugas y cancelación
← Volver a Go Academy