¿Cómo se puede garantizar la seguridad en el acceso concurrente a un objeto Map utilizando mecanismos de bloqueo como Mutex?

En Go, para garantizar la seguridad de los hilos del objeto map, se puede usar un mutex (sync.Mutex). Dado que el map estándar no es seguro para el acceso concurrente, es necesario proteger las operaciones de lectura y escritura con un bloqueo.

Ejemplo:

import (
    "sync"
)

type SafeMap struct {
    mu sync.Mutex
    m  map[string]int
}

func NewSafeMap() *SafeMap {
    return &SafeMap{
        m: make(map[string]int),
    }
}

func (s *SafeMap) Get(key string) (int, bool) {
    s.mu.Lock()
    defer s.mu.Unlock()
    val, ok := s.m[key]
    return val, ok
}

func (s *SafeMap) Set(key string, value int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[key] = value
}

func (s *SafeMap) Delete(key string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    delete(s.m, key)
}

De esta manera, antes de cada operación con map, se bloquea el mutex, lo que previene accesos simultáneos desde varias goroutines y evita condiciones de carrera.