¿Qué sabes sobre el paquete sync.Map?

El paquete sync.Map proporciona una tabla hash segura para acceso concurrente. Está optimizado para casos en los que las claves se leen principalmente y se escriben con menos frecuencia.

Características principales:

• Seguridad en paralelo: Garantiza acceso seguro desde múltiples goroutines sin bloqueos explícitos.
• Optimizado para lectura: La primera lectura de cada clave se almacena en caché como solo lectura. Las lecturas posteriores desde esta caché no requieren bloqueo.
• Eliminación dinámica: Los elementos eliminados se marcan primero como eliminados, y la eliminación real ocurre bajo ciertas condiciones para minimizar bloqueos durante la escritura.
• Ausencia del método Len(): La compatibilidad con Len() haría que la implementación segura para paralelo sea compleja y costosa.
• No apto para datos en constante cambio: Con escrituras y eliminaciones frecuentes, puede ser menos eficiente que usar un mutex con un map normal.

Métodos principales:

• Load(key any) (value any, ok bool): Carga el valor asociado con la clave. Si la clave no existe, devuelve false.
• Store(key, value any): Guarda un valor para la clave. Puede usarse para agregar o actualizar.
• LoadOrStore(key any, value any) (actual any, loaded bool): Carga el valor asociado con la clave si ya existe. De lo contrario, guarda el valor especificado. Devuelve el valor real y un indicador de si el valor fue cargado (true) o almacenado (false).
• Delete(key any): Elimina el valor para la clave.
• Range(f func(key, value any) bool): Itera sobre los elementos en el mapa en orden arbitrario. La función f se llama para cada par clave-valor. Si f devuelve false, la iteración se detiene.

Ejemplo de uso:

import "sync"

var m sync.Map

func process(key string, value int) {
	m.Store(key, value)

	v, ok := m.Load(key)
	if ok {
		// Usar v
	}

	m.Range(func(key, value any) bool {
		// Procesar elementos
		return true // Continuar la iteración
	})
}

En general, sync.Map es una buena opción cuando las lecturas paralelas superan significativamente a las escrituras y eliminaciones. De lo contrario, usar un map junto con sync.Mutex o sync.RWMutex puede ser más apropiado.