Prácticas recomendadas para los fundamentos de concurrencia

Comparta memoria comunicándose, y cuándo usar bloqueos.

Estas reglas mantienen las goroutines acotadas, los canales libres de deadlocks y el estado compartido libre de condiciones de carrera, desde los portátiles de desarrollo hasta los servicios de producción.

Cómo usar esta lista

• Aplique durante la revisión de código en cualquier PR que agregue go, canales o tipos sync.
• Ejecute go test -race ./... y golangci-lint en los paquetes modificados antes de fusionar.
• Cuando una regla entre en conflicto con datos de benchmark, documente la excepción con un enlace al perfil.
• Vuelva a revisar después de las actualizaciones de Go; la semántica del planificador y de los bucles evoluciona en las diferentes versiones.

A - Goroutines y ciclo de vida

• Sepa cómo termina el trabajo antes de comenzarlo. Cada go necesita una vía de finalización: WaitGroup, close(ch) o cancelación de context.
• Nunca permita que main retorne mientras los workers siguen ejecutándose. La salida mata el proceso sin esperar a las goroutines en segundo plano.
• Limite el fan-out para entradas grandes. Use pools de workers en lugar de una goroutine por fila, solicitud o archivo.
• Pase las variables del bucle a los parámetros de la goroutine. Defensivo en todas las versiones compatibles de Go; documenta la intención en las bibliotecas.
• Observe runtime.NumGoroutine() en las pruebas de resistencia. El crecimiento monotónico indica fugas en recepciones de canales bloqueadas.

B - Canales y select

• Por defecto, use canales sin búfer para la semántica de traspaso. Agregue búfer solo cuando los perfiles muestren desequilibrio entre productor y consumidor.
• Solo los remitentes cierran los canales. Los receptores detectan el cierre con range o v, ok := <-ch.
• Nunca envíe a un canal cerrado. Proteja los cierros compartidos con sync.Once o una goroutine coordinadora dedicada.
• Evite bucles de sondeo select + default. Los sondeos activos consumen CPU; bloquee o use temporizadores/plazos de contexto.
• Prefiera context.WithTimeout sobre time.After en bucles de servidor. Reutilice temporizadores en rutas críticas para reducir las asignaciones.

C - Mutex, atómicos y estado compartido

• Proteja mapas y slices mutados por múltiples goroutines. Los mapas nativos no son seguros para concurrencia sin sincronización.
• Use defer mu.Unlock() inmediatamente después de Lock. Sobrevive a pánicos y retornos tempranos en los manejadores.
• Elija un orden de bloqueo cuando interactúen múltiples mutex. Documente el orden en los comentarios del tipo para prevenir deadlocks.
• Mantenga los bloqueos durante microsegundos, no milisegundos. Copie los datos, libere y luego realice E/S o RPC sin bloqueo.
• Opte por atómicos solo para contadores/flags simples. Los invariantes de múltiples campos aún necesitan mutex.

D - Pruebas, detector de condiciones de carrera y producción

• Ejecute go test -race en CI para paquetes que usan concurrencia. Trate los nuevos informes de condiciones de carrera como bloqueadores de lanzamiento.
• Estrese las pruebas inestables con -count=50 -race. Las intercalaciones exponen condiciones de carrera que pasan una vez.
• No envíe binarios con -race a producción sensible a la latencia. Use pruebas de resistencia en staging con compilaciones de condiciones de carrera en su lugar.
• Instale recuperación de pánicos en los límites HTTP/gRPC. Los interceptores de chi, gin, echo y gRPC capturan pánicos por solicitud.
• Transmita context.Context a través de árboles de llamadas concurrentes. La cancelación detiene las goroutines descendentes cuando los clientes se desconectan.

Preguntas frecuentes

Relacionado

• Concurrencia en Go: Goroutines y Canales Primero - resumen de la sección
• Fundamentos de Concurrencia - ejemplos introductorios ejecutables
• Canales: Reglas de Búfer, Sin Búfer y Cierre - semántica de cierre
• Detector de Condiciones de Carrera: Ejecución e Interpretación de Salida - flujo de trabajo de CI para condiciones de carrera
• sync.Mutex, RWMutex y WaitGroup - disciplina de bloqueo

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