Un servicio en Go lleva una semana corriendo con gráficas en verde y, de pronto, la memoria RAM empieza a subir en silencio. El recolector de basura choca cada vez más seguido contra GOMEMLIMIT, el procesador se calienta y en /debug/pprof/goroutine aparecen tres mil gorutinas colgadas. Adivina tú cuáles están esperando una respuesta bajo carga y cuáles quedaron atrapadas para siempre.
En Go 1.27 resolvieron este problema en el propio runtime. El perfil integrado goroutineleak, que en Go 1.26 todavía se escondía tras el flag GOEXPERIMENT=goroutineleakprofile, salió de fase experimental y viene activo por defecto. Vlad Saioc lo explicó en The Go Blog: el detector se apoya en el recolector de basura y, casi sin falsos positivos, señala justo las líneas donde las gorutinas se atascaron para siempre.
Por qué los tests y el pprof habitual dejan pasar fugas silenciosas
Una gorutina es un hilo ligero de ejecución gestionado por el runtime de Go. Lanzarlas por lotes sale barato, pero si una gorutina se duerme en un canal o un mutex y ya no queda nadie para despertarla, ocurre una fuga. La gorutina colgada no desaparece: retiene su pila y todos los objetos a los que apuntan sus variables. En cada ciclo, el recolector de basura vuelve a recorrer ese grafo muerto de referencias y quema CPU en vano.
Antes de Go 1.27, estos bugs se cazaban sobre todo en tests. La librería uber-go/goleak revisa después de un test unitario si quedaron gorutinas sobrantes. El paquete testing/synctest de Go 1.25 permite fijar el orden de eventos concurrentes y reproducir condiciones de carrera de forma estable. Pero ambas herramientas viven en los tests, mientras que en producción el tráfico y los timeouts crean escenarios que nadie probó.
El /debug/pprof/goroutine normal también falla en un servicio vivo: junta a todas las gorutinas bloqueadas sin distinguir un bloqueo eterno de una espera normal. Una fuga lenta de una o dos gorutinas por hora se camufla en ese ruido durante años.
Cazando workers colgados con /debug/pprof/goroutineleak
No hace falta cambiar el código del servicio para usar el nuevo perfil. El tipo goroutineleak viene integrado en runtime/pprof, y si el proyecto ya importa net/http/pprof, el endpoint /debug/pprof/goroutineleak aparece automáticamente.
Comprobémoslo con un error clásico del blog de Go (bugs parecidos se encontraron en producción en Uber). La función processWorkItems lanza workers y recoge respuestas de un canal sin búfer make(chan result), donde el envío se bloquea hasta que alguien lee. Al primer error, la función sale de inmediato:
package main
import (
"errors"
"log"
"net/http"
_ "net/http/pprof"
)
type workItem int
type workResult int
type result struct {
res workResult
err error
}
func processWorkItem(w workItem) (workResult, error) {
if w <= 0 {
return 0, errors.New("invalid work item")
}
return workResult(w * 2), nil
}
func processWorkItems(ws []workItem) ([]workResult, error) {
// Sin búfer: con un return temprano los workers se cuelgan al enviar
ch := make(chan result)
for _, w := range ws {
go func() {
res, err := processWorkItem(w)
ch <- result{res, err}
}()
}
var out []workResult
for range len(ws) {
r := <-ch
if r.err != nil {
return nil, r.err
}
out = append(out, r.res)
}
return out, nil
}
func handleWork(w http.ResponseWriter, _ *http.Request) {
items := []workItem{1, 2, 3, 4, 0, 6, 7, 8, 9, 10}
if _, err := processWorkItems(items); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
}
}
func main() {
http.HandleFunc("/work", handleWork)
log.Fatal(http.ListenAndServe("localhost:6060", nil))
}
En el elemento con valor cero, processWorkItems recibe un error, hace un return temprano y abandona el canal. El resto de los workers llegan a ch <- result{res, err} y quedan bloqueados para siempre porque ya nadie lee de ch. Cada petición a /work deja en memoria un nuevo lote de «zombis».
Compilamos el binario, lo arrancamos, enviamos peticiones a /work y capturamos el perfil con curl y go tool pprof:
go build -o leaky && ./leaky
# En otra terminal llamamos a /work y descargamos el perfil de fugas
curl http://localhost:6060/work
curl http://localhost:6060/debug/pprof/goroutineleak > leak.prof
go tool pprof leak.prof
Tras una serie de peticiones así, el comando list processWorkItems en la consola interactiva de pprof señala sin ruido directo la línea problemática:
Type: goroutineleak
(pprof) list processWorkItems
Total: 116
ROUTINE ======================== main.processWorkItems.func1 in .../main.go
0 116 (flat, cum) 100% of Total
. . 31: go func() {
. . 32: res, err := processWorkItem(w)
. 116 33: ch <- result{res, err}
. . 34: }()
En el reporte no aparecen gorutinas en segundo plano del servidor HTTP ni temporizadores: son exactamente 116 envíos atascados. La corrección cabe en una línea: darle al canal un búfer igual al número de tareas.
// Un búfer de len(ws) permite a los workers escribir la respuesta y salir
ch := make(chan result, len(ws))
Ahora cada worker deja su resultado en el búfer sin bloquearse y termina con normalidad, y el recolector de basura limpia el canal más tarde.
Tres trampas reales de producción: range, mutex y canal
En bases de código grandes, las fugas no solo se esconden en retornos tempranos, sino también en bucles o primitivas del paquete sync como sync.Mutex y sync.WaitGroup. Aquí tienes tres casos reales del artículo de Go y proyectos abiertos.
El primero es un canal sin cerrar en for range. El bucle range ch solo termina tras close(ch) y cuando se vacía el búfer. Si olvidas cerrar el canal, todos los workers se quedan esperando para siempre:
func noCloseRange(list []any, workers int) {
ch := make(chan any)
for i := 0; i < workers; i++ {
go func() {
for item := range ch {
_ = item
}
}()
}
for _, item := range list {
ch <- item
}
// Sin close(ch) los workers quedarán colgados en range ch
close(ch)
}
Trampa extra: si por error pasas workers == 0, entonces será la propia gorutina padre la que se quede bloqueada en ch <- item. El perfil goroutineleak también atrapa eso.
El segundo caso es un bug real de CockroachDB. Un método en bucle toma un sync.Mutex, comprueba una bandera y sale con break, olvidando soltar el candado:
type Gossip struct {
mu sync.Mutex
closed bool
}
func (g *Gossip) bootstrap() {
for {
g.mu.Lock()
if g.closed {
// Sin Unlock() la siguiente llamada se colgará en Lock()
g.mu.Unlock()
break
}
g.mu.Unlock()
}
}
La primera llamada con closed: true sale dejando el mutex bloqueado, y cualquier gorutina siguiente se detiene en g.mu.Lock() eternamente. Ya nadie puede desbloquearlo, y el perfilador apunta con exactitud a la línea de Lock().
El tercer caso es el bug Moby28462 del motor de Docker. Allí, el método StateChanged retenía c.Lock() y enviaba una señal por el canal sin búfer s.stop <- struct{}{}, mientras monitor() ya había entrado en default y esperaba ese mismo c.Lock(). El bloqueo mutuo se corrigió cerrando el canal:
// close() no bloquea, Lock() se libera y monitor()
// sale por la rama case <-stop
func (s *Health) CloseMonitorChannel() {
if s.stop != nil {
close(s.stop)
}
}
Cerrar el canal ocurre al instante sin esperar al lector, el mutex se libera y el bucle en segundo plano monitor() termina como debe.
Cómo distingue el runtime una fuga de una espera normal
goroutineleak no se basa en heurísticas de tiempo, sino en un grafo estricto de alcanzabilidad. El algoritmo nació del estudio ASPLOS 2025 de la Universidad de Aarhus, la Universidad de Washington en St. Louis y Uber, y en Go lo afinaron junto con Michael Knyszek, Michael Pratt y PJ Malloy.
La regla central es la viveza inductiva (liveness): una gorutina está viva si no está bloqueada en una primitiva de sincronización, o si al menos una primitiva en la que espera es alcanzable por referencias desde otra gorutina viva. Si ninguna gorutina activa llega hasta ese canal o mutex, ya nadie podrá despertar a la que duerme.
El runtime usa el recolector de basura concurrente tricolor (tri-color mark-and-sweep GC, incluido Green Tea GC) y comprueba la alcanzabilidad en cinco pasos:
- En las raíces iniciales (
mark roots) entran las variables globales y solo las gorutinas no bloqueadas, no todas. - La fase normal de marcado recorre referencias desde las raíces y marca la memoria alcanzable.
- El runtime revisa las gorutinas que siguen bloqueadas: si la primitiva donde espera una gorutina quedó marcada en el paso 2, se la declara viva, se añade a las raíces y se repite el marcado.
- Cuando ya no aparecen gorutinas vivas nuevas, todas las bloqueadas restantes reciben el estado
leaked. - El marcado se ejecuta una última vez incluyendo las gorutinas «fugadas» en las raíces, para que el GC no borre su memoria. Al terminar el ciclo,
pprofcaptura las pilas y deja solo lasleaked.
Dónde están los límites del detector y cuánto cuesta en CPU
Esa precisión sin falsos positivos tiene sus fronteras. Primero, el perfil rastrea únicamente las primitivas nativas de Go: envío y lectura en canales (incluidos canales nil), select bloqueante sin default (incluido select {} vacío), además de sync.Mutex, sync.RWMutex, sync.WaitGroup y sync.Cond. Los bloqueos en E/S de red o archivos, llamadas al sistema y spinlocks propios no aparecen aquí.
Segundo, molesta el llamado memory overreach: si queda una referencia a un canal olvidado en una variable global o en una gorutina viva, el GC lo considera alcanzable y guarda silencio, aunque nadie vuelva a escribir ahí. Esto se evita reduciendo el ámbito de visibilidad de las primitivas.
Por último, el detector solo ve fugas que ya ocurrieron. En memoria el costo es casi cero, pero en CPU, en el caso patológico de una «cadena» (daisy-chain: G0 -> P1 -> G1 -> P2 -> G2 ...), el marcado avanza en serie y revisar gorutinas bloqueadas da una complejidad en el peor caso de O(n²) por ciclo de GC. Aun así, el recolector corre de forma concurrente con el servicio y la fuga no desaparece con el tiempo: en producción basta con capturar /debug/pprof/goroutineleak cada cuatro horas, complementando goleak y testing/synctest en los tests.

