Conceptos básicos del tiempo de ejecución

10 ejemplos para empezar con Runtime y GC: 7 básicos y 3 intermedios.

Prerrequisitos

• Instale Go 1.26.x o posterior desde go.dev/dl.
• Cree un módulo: mkdir rtdemo && cd rtdemo && go mod init example.com/rtdemo.
• Guarde los fragmentos como main.go (o archivos separados en un solo paquete) y ejecute con go run ..
• Para la salida del rastreo de GC, ejecute con GODEBUG=gctrace=1 go run . (verboso; úselo en programas pequeños).

Ejemplos básicos

1. Leer MemStats

runtime.ReadMemStats crea instantáneas de los contadores del asignador y del GC.

package main
 
import (
    "fmt"
    "runtime"
)
 
func main() {
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    fmt.Printf("asignación de heap: %d KiB\n", ms.HeapAlloc/1024)
    fmt.Printf("goroutines: %d\n", runtime.NumGoroutine())
}

• HeapAlloc son los bytes asignados actualmente en el heap (objetos alcanzables).
• ReadMemStats detiene el mundo brevemente; no lo llame en cada solicitud en rutas críticas.
• Empareje con exportadores go_memstats_* de Prometheus en producción en lugar de encuestar en manejadores.

Relacionado: El tiempo de ejecución de Go: Planificador, GC y Memoria - modelo mental del tiempo de ejecución

2. NumGoroutine

Cuente las goroutines activas para la depuración de fugas.

package main
 
import (
    "fmt"
    "runtime"
    "time"
)
 
func main() {
    fmt.Println("inicio:", runtime.NumGoroutine())
    go func() {
        time.Sleep(200 * time.Millisecond)
    }()
    time.Sleep(10 * time.Millisecond)
    fmt.Println("con trabajador:", runtime.NumGoroutine())
}

• Incluye la goroutine principal y cualquier trabajador de fondo del tiempo de ejecución.
• Un recuento creciente bajo carga constante a menudo indica esperas olvidadas de WaitGroup o envíos de canales bloqueados.
• Exporte como un gauge y compare con la tasa de solicitudes, no solo con un umbral absoluto.

Relacionado: Pilas de Goroutines y Crecimiento de Pilas - costo de pila por goroutine

3. GOMAXPROCS y NumCPU

Vea cuántos Ps utiliza el planificador.

package main
 
import (
    "fmt"
    "runtime"
)
 
func main() {
    fmt.Println("NumCPU:", runtime.NumCPU())
    fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0))
}

• GOMAXPROCS(0) lee la configuración actual sin cambiarla.
• En compilaciones de Go compatibles con cgroups, el tiempo de ejecución puede alinear automáticamente los Ps con la cuota de CPU del contenedor.
• Establezca explícitamente solo cuando haya medido una discrepancia entre la cuota y el paralelismo observado.

Relacionado: Goroutines: Costo de Creación y Resumen de Planificación - modelo GPM

4. GC manual para diagnósticos

Forzar una recolección para medir el heap activo después de la limpieza.

package main
 
import (
    "fmt"
    "runtime"
)
 
func main() {
    data := make([]byte, 10<<20) // 10 MiB
    _ = data
    runtime.GC()
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    fmt.Printf("heap después de GC: %d MiB\n", ms.HeapAlloc/(1<<20))
}

• runtime.GC() ejecuta un ciclo completo y regresa cuando se completa.
• Útil en benchmarks y diagnósticos puntuales, no en rutas de producción por solicitud.
• Las referencias activas mantienen HeapAlloc alto incluso inmediatamente después del GC.

Relacionado: Recolector de Basura: Barrido de Marca Tri-Color y Control de Ritmo - lo que hace un ciclo

5. Totales de pausa de GC

Inspeccionar el tiempo acumulado de pausa STW.

package main
 
import (
    "fmt"
    "runtime"
)
 
func main() {
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    fmt.Printf("ciclos de GC: %d\n", ms.NumGC)
    fmt.Printf("total de pausa: %d ms\n", ms.PauseTotalNs/1e6)
    if ms.NumGC > 0 {
        last := ms.PauseNs[(ms.NumGC+255)%256]
        fmt.Printf("última pausa: %d µs\n", last/1e3)
    }
}

• PauseNs es un búfer circular de duraciones de pausa recientes.
• Los SLO de latencia de cola se preocupan por las pausas individuales, no solo por los totales acumulados.
• Compare antes/después de los cambios de GOGC o GOMEMLIMIT bajo carga.

Relacionado: GOGC, GOMEMLIMIT y Finalizadores - perillas de ajuste

6. Tasa de asignador con Mallocs

Vea cuántos objetos asigna cada ciclo.

package main
 
import (
    "fmt"
    "runtime"
)
 
func allocN(n int) {
    for i := 0; i < n; i++ {
        _ = make([]byte, 1024)
    }
}
 
func main() {
    var before runtime.MemStats
    runtime.ReadMemStats(&before)
    allocN(1000)
    var after runtime.MemStats
    runtime.ReadMemStats(&after)
    fmt.Println("delta de mallocs:", after.Mallocs-before.Mallocs)
}

• Los contadores Mallocs y Frees aumentan monótonamente durante la vida útil del proceso.
• Una alta tasa de asignación impulsa la CPU del GC incluso cuando el heap activo permanece pequeño.
• go test -bench con benchmem informa las asignaciones por operación.

Relacionado: Análisis de Escape y Asignación en Pila vs. Heap - reducción de asignaciones de heap

7. debug.FreeOSMemory

Devolver los tramos no utilizados al sistema operativo después de un pico.

package main
 
import (
    "fmt"
    "runtime"
    "runtime/debug"
)
 
func main() {
    _ = make([]byte, 50<<20)
    runtime.GC()
    debug.FreeOSMemory()
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    fmt.Printf("heap inactivo: %d MiB\n", ms.HeapIdle/(1<<20))
}

• El tiempo de ejecución mantiene los tramos liberados en grupos; FreeOSMemory fomenta devolverlos al sistema operativo.
• Útil después de trabajos raros por lotes grandes en pods con memoria limitada.
• No reemplaza la corrección de fugas o cachés sobredimensionadas.

Relacionado: Fugas de Memoria en Go: Causas Comunes - patrones de fugas

Ejemplos intermedios

8. GODEBUG gctrace

Imprimir una línea por ciclo de GC en stderr.

package main
 
func main() {
    for i := 0; i < 1_000_000; i++ {
        _ = make([]byte, 256)
    }
}

• Ejecutar: GODEBUG=gctrace=1 go run .
• Cada línea muestra el tiempo de reloj, el número de GC, el tamaño del heap y el desglose de la pausa.
• Úselo durante las pruebas de carga para ver si el control de ritmo coincide con las expectativas antes de cambiar GOGC.

Relacionado: Prácticas recomendadas de Runtime y GC - flujo de trabajo de ajuste de producción

9. Paquete runtime/metrics

Leer métricas estructuradas de GC y memoria (Go 1.16+).

package main
 
import (
    "fmt"
    "runtime/metrics"
)
 
func main() {
    samples := []metrics.Sample{
        {Name: "/gc/heap/live:bytes"},
        {Name: "/sched/goroutines:goroutines"},
    }
    metrics.Read(samples)
    fmt.Println("heap activo:", samples[0].Value.Uint64())
    fmt.Println("goroutines:", samples[1].Value.Uint64())
}

• Los nombres de las métricas son estables para los paneles; prefiera usarlos sobre el análisis manual de MemStats en los exportadores.
• Consulte go doc runtime/metrics para ver el catálogo completo.
• /gc/cycles/total:gc-cycles se empareja bien con los perfiles de CPU durante las regresiones de GC.

Relacionado: Perfilado de CPU y Heap con pprof - perfilar bajo carga

10. Comparar la huella de la pila frente al heap

Correlacionar StackInuse con la expansión de goroutines.

package main
 
import (
    "fmt"
    "runtime"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10_000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            var buf [4096]byte // crece la pila si es necesario
            _ = buf
        }()
    }
    wg.Wait()
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    fmt.Printf("pilas en uso: %d MiB, goroutines: %d\n",
        ms.StackInuse/(1<<20), runtime.NumGoroutine())
}

• StackInuse es la memoria agregada de la pila en todas las goroutines.
• La gran expansión combinada con pilas profundas puede dominar el RSS sin objetos de heap grandes.
• Limite la concurrencia con grupos de trabajadores cuando StackInuse rastrea el recuento de solicitudes linealmente.

Relacionado: Pilas de Goroutines y Crecimiento de Pilas - reglas de crecimiento y copia

Versiones de pila: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, 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).