var userSessions = map[string]Session{}

func SaveSession(userID string, session Session) {
    userSessions[userID] = session
}

func GetSession(userID string) (Session, bool) {
    session, ok := userSessions[userID]
    return session, ok
}

@Reviewer: package変数のmapを複数リクエストから直接読み書きしているため、同時アクセス時にデータ競合や `concurrent map writes` が起きる可能性があります。mapの所有者を構造体に閉じ込め、読み書きの排他方針を明示してください。

type SessionStore struct {
    mu       sync.RWMutex
    sessions map[string]Session
}

func NewSessionStore() *SessionStore {
    return &SessionStore{
        sessions: make(map[string]Session),
    }
}

@Reviewer: mapがpackage変数として露出しているため、更新経路を追い切れません。mapと排他制御を同じ構造体にまとめ、操作メソッド経由で扱う設計にしてください。

func (s *SessionStore) Save(userID string, session Session) {
    s.mu.Lock()
    defer s.mu.Unlock()

    s.sessions[userID] = session
}

func (s *SessionStore) Get(userID string) (Session, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()

    session, ok := s.sessions[userID]
    return session, ok
}

@Reviewer: 書き込み側だけmutexで保護されていますが、読み取り側が同じmapをロックなしで参照しています。読み取りも `RLock` に入れ、mapアクセスの方針を統一してください。

func (s *SessionStore) All() map[string]Session {
    return s.sessions
}

@Reviewer: 内部mapをそのまま返すと、呼び出し側がロック外で更新できてしまいます。必要な値だけ返すか、ロック内でコピーしたmapを返してください。

func (s *SessionStore) Snapshot() map[string]Session {
    s.mu.RLock()
    defer s.mu.RUnlock()

    copied := make(map[string]Session, len(s.sessions))
    for userID, session := range s.sessions {
        copied[userID] = session
    }
    return copied
}

type SessionStore struct {
    mu       sync.RWMutex
    sessions map[string]Session
}

func NewSessionStore() *SessionStore {
    return &SessionStore{
        sessions: make(map[string]Session),
    }
}

func (s *SessionStore) Save(userID string, session Session) {
    s.mu.Lock()
    defer s.mu.Unlock()

    s.sessions[userID] = session
}

func (s *SessionStore) Get(userID string) (Session, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()

    session, ok := s.sessions[userID]
    return session, ok
}

func (s *SessionStore) Delete(userID string) {
    s.mu.Lock()
    defer s.mu.Unlock()

    delete(s.sessions, userID)
}

func (s *SessionStore) Snapshot() map[string]Session {
    s.mu.RLock()
    defer s.mu.RUnlock()

    copied := make(map[string]Session, len(s.sessions))
    for userID, session := range s.sessions {
        copied[userID] = session
    }
    return copied
}

var sessions sync.Map

func SaveSession(userID string, session Session) {
    sessions.Store(userID, session)
}

func GetSession(userID string) (Session, bool) {
    value, ok := sessions.Load(userID)
    if !ok {
        return Session{}, false
    }
    return value.(Session), true
}

@Reviewer: `sync.Map` の採用理由が読めません。キーごとに独立した高頻度アクセスなのか、通常のmapとmutexで十分なのか、値の型契約を含めて説明してください。

counts := map[string]int{}

for _, item := range items {
    go func(item Item) {
        counts[item.Category]++
    }(item)
}

@Reviewer: 複数goroutineから同じmapへ直接書き込んでいます。mutexで守るか、各goroutineの結果をchannelで集約し、map更新を単一goroutineに閉じてください。

type CountResult struct {
    Category string
}

results := make(chan CountResult)

for _, item := range items {
    go func(item Item) {
        results <- CountResult{Category: item.Category}
    }(item)
}

counts := map[string]int{}
for i := 0; i < len(items); i++ {
    result := <-results
    counts[result.Category]++
}