¿De qué maneras se puede garantizar un trabajo seguro con la colección Map en un entorno multihilo?

En Go, el mapa estándar (map) no es seguro para la concurrencia en lectura y escritura desde diferentes goroutines. Para garantizar un uso seguro del mapa en un entorno multihilo, se pueden usar los siguientes enfoques:

1. Sincronización con mutex

Usar sync.Mutex o sync.RWMutex para proteger el acceso al mapa. Al escribir, bloquear el mutex para escritura, y al leer, para lectura (si se usa RWMutex).

import "sync"

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

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

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

2. Uso de sync.Map

En Go, existe una estructura especializada sync.Map, optimizada para acceso concurrente y que no requiere sincronización manual.

import "sync"

var m sync.Map

// Escritura
m.Store("key", 42)

// Lectura
val, ok := m.Load("key")

3. Uso de canales (channels)

Se puede organizar el acceso al mapa a través de una goroutine que maneje las solicitudes de lectura y escritura mediante canales, asegurando un acceso secuencial.

La elección del método depende de los requisitos específicos de rendimiento y complejidad de implementación.