How can safe working with a Map collection in a multithreaded environment be ensured?

In Go, the standard map is not thread-safe for concurrent read and write operations from different goroutines. To ensure safe operation with a map in a multithreaded environment, the following approaches can be used:

1. Synchronization with mutex

Use sync.Mutex or sync.RWMutex to protect access to the map. Lock the mutex for writing when updating, and for reading when accessing (if using 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. Using sync.Map

Go provides a specialized sync.Map structure optimized for concurrent access that does not require manual synchronization.

import "sync"

var m sync.Map

// Store a value
m.Store("key", 42)

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

3. Using channels

Access to the map can be organized through a dedicated goroutine that handles read and write requests via channels, ensuring sequential access.

The choice of method depends on specific performance requirements and implementation complexity.