Limitación de goroutines
Controle la concurrencia
Limitación de goroutines es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 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.
Limitación de la concurrencia
A veces no se limita la cantidad por segundo, sino cuántas gorutinas se ejecutan a la vez. Esto limita la carga simultánea sobre un recurso, independientemente del momento en que se produzca.
- Limita el paralelismo
- Protege los pools de conexiones
- Evita picos de memoria
El canal semáforo
Un canal con búfer funciona como un semáforo contador. Su capacidad equivale a la concurrencia máxima. Adquirir un recurso envía un token; liberarlo recibe uno.
sem := make(chan struct{}, 3)Adquirir y liberar
Antes de iniciar el trabajo, envíe un valor al canal para adquirir un espacio (la operación se bloquea si está lleno). Al terminar, reciba un valor para liberarlo y dejar el espacio disponible para otra gorutina.
sem <- struct{}{} // acquire
// do work
<-sem // releasePor qué struct{}
Una estructura vacía struct{}{} ocupa cero bytes. Al usarla como tipo de elemento del canal, el semáforo se convierte en una señal pura sin desperdiciar memoria.
Limitar un bucle
Inicie una gorutina por tarea, pero haga que cada una pase por el semáforo. Como máximo, cap gorutinas realizarán trabajo real simultáneamente; las demás se bloquearán al adquirir un espacio.
for _, task := range tasks {
sem <- struct{}{}
go func(t Task) {
defer func() { <-sem }()
process(t)
}(t)
}Combinar con WaitGroup
El semáforo limita la concurrencia, pero no indica cuándo terminan todas las tareas. Combínelo con un sync.WaitGroup para esperar a que finalicen todas.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
defer func() { <-sem }()
process(t)
}()Liberar en defer
Libere siempre el espacio en un defer para que se libere incluso si el trabajo provoca un panic o retorna antes de tiempo. Olvidarse de liberarlo filtra espacios y, con el tiempo, provoca un interbloqueo de los nuevos adquirentes.
Una ejecución completa con limitación
Este programa ejecuta ocho tareas con un máximo de dos tareas simultáneas y muestra el inicio y el final para demostrar el límite en acción.
package main
import (
"fmt"
"sync"
"time"
)
func main() {
sem := make(chan struct{}, 2)
var wg sync.WaitGroup
for i := 0; i < 8; i++ {
wg.Add(1)
sem <- struct{}{}
go func(id int) {
defer wg.Done()
defer func() { <-sem }()
fmt.Println("start", id)
time.Sleep(20 * time.Millisecond)
fmt.Println("end", id)
}(i)
}
wg.Wait()
fmt.Println("done")
}errgroup con SetLimit
El paquete golang.org/x/sync/errgroup ofrece SetLimit para limitar un grupo y propagar el primer error. Es una alternativa más limpia en muchos casos, aunque se trata de un paquete externo.
Limitación frente a un pool de workers
Un pool de workers reutiliza un conjunto fijo de gorutinas que extraen tareas de una cola. La limitación mediante un semáforo inicia una gorutina por tarea, pero limita las que están activas. Los pools consumen menos recursos con cantidades enormes de tareas; los semáforos son más sencillos de incorporar.
Elegir el límite
Para las llamadas a la base de datos, establezca el límite en el tamaño del pool de conexiones o por debajo de este. Para HTTP saliente, ajústelo al límite de conexiones del host. Un límite demasiado alto agota los recursos; uno demasiado bajo desaprovecha la capacidad.
Comprobación rápida
Compruebe sus conocimientos sobre la limitación.
Repaso
Ha aprendido a limitar gorutinas:
- Un canal con búfer actúa como un semáforo contador
- Adquiera enviando y libere recibiendo en un defer
- Los elementos struct{} cuestan cero bytes
- Combínelo con WaitGroup para esperar a que finalice el trabajo
- Dimensione el límite según el recurso protegido
Aprende Go con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Limitación de goroutines» es gratis?
Sí — el texto completo de «Limitación de goroutines» 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 «Limitación de goroutines»?
Controle la concurrencia 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 3 de 4.
¿Cuánto tiempo toma la lección «Limitación de goroutines»?
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
- Concepto del token bucket
- golang.org/x/time/rate
- Limitación de goroutines
- Retirada progresiva y reintento