Entender el contrato

Un mutex coordina acceso exclusivo al estado compartido. Toda operación que participe en la misma regla debe seguir el bloqueo. Protege escrituras y lecturas si pueden coincidir. Esperar trabajadores resuelve finalización, pero no vuelve seguros sus incrementos simultáneos.

Counter reúne mutex y entero protegido. Add y Value bloquean el mismo mutex. Los receptores por puntero mantienen una instancia y evitan copiar un mutex usado. El valor cero de sync.Mutex está listo; el contador no necesita constructor.

Trabajar el ejemplo

Cuatro trabajadores incrementan cien veces y main espera e imprime 400. El bloqueo cubre solo el cambio de estado. WaitGroup establece cuándo terminó el trabajo; mutex protege los incrementos durante la ejecución. Cada mecanismo resuelve su responsabilidad.

package main

import (
    "fmt"
    "sync"
)

type Counter struct { mu sync.Mutex; n int }
func (c *Counter) Add() { c.mu.Lock(); c.n++; c.mu.Unlock() }
func (c *Counter) Value() int { c.mu.Lock(); defer c.mu.Unlock(); return c.n }

func main() {
    var counter Counter
    var wg sync.WaitGroup
    for i := 0; i < 4; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 100; j++ { counter.Add() }
        }()
    }
    wg.Wait()
    fmt.Println(counter.Value())
}

Revisar este límite

Evita mantener mutex durante red lenta salvo necesidad explícita de la regla. Bloquear recursivamente un Mutex ordinario causa deadlock. Mantén el orden entre varios locks y expón métodos en lugar de referencias mutables a los campos protegidos.

Practicar con otra entrada

Ejecuta con detector de carreras en una plataforma compatible. Añade Reset usando el mismo mutex y razona si reiniciar durante el trabajo tiene significado útil.

Referencias y lecturas adicionales

¿Necesitas apoyo con tu backend Go?

Colaboro con equipos de ingeniería en proyectos concretos de Go y plataformas Kubernetes, con disponibilidad limitada.

Ver servicios de consultoría Go