¿Cómo se puede evitar una situación de bloqueo mutuo (deadlock) en un programa en Go?

El bloqueo mutuo en Go suele ocurrir por un uso incorrecto de mutexes y canales. Se puede evitar de las siguientes maneras:

• Adquisición ordenada de mutexes: Al adquirir varios mutexes, hazlo siempre en el mismo orden en todas las goroutines.
• Timeouts para bloqueos: Usa contextos con timeouts al esperar bloqueos o recibir de canales, para evitar esperas infinitas.
• Canales no bufferizados: Entiende que los canales no bufferizados requieren tanto al emisor como al receptor para continuar la ejecución. Un uso incorrecto puede causar bloqueo.
• Canales bufferizados: Elige correctamente el tamaño del buffer del canal. Un buffer demasiado pequeño puede causar bloqueo si los emisores y receptores no están sincronizados.
• Uso de select: Cuando trabajes con múltiples canales, usa el operador select con una rama default o timeout, para no bloquearte esperando un solo canal.
• Análisis de código: Usa análisis estático (go vet, staticcheck) y herramientas para detectar condiciones de carrera (go run -race), que también pueden ayudar a identificar posibles lugares de bloqueos mutuos.
• Jerarquía de recursos: Si los recursos tienen una jerarquía, adquiérelos de arriba hacia abajo.
• Evitar dependencias cíclicas: No crees situaciones donde la goroutine A espera un recurso ocupado por B, y B espera un recurso ocupado por A.

Ejemplo de uso de select con timeout:

import (
	"context"
	"time"
)

func ejemplo(ch chan int) {
	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
	defer cancel()

	select {
	case val := <-ch:
		// Procesar valor
		_ = val
	case <-ctx.Done():
		// Se produjo un timeout
	}
}