Golang并发写入的线程安全Map存储方案

我打算为用户提供的另一个选项是Redis，但这适用于那些不希望有外部依赖的用户。

在Go语言中处理并发写入Map的场景，标准做法是使用sync.Map或结合互斥锁的普通Map。对于你的MapReduce单词统计场景，我建议使用sync.Map，因为它专门为并发访问优化，无需额外的队列系统。

以下是一个实现示例：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var result sync.Map
	var wg sync.WaitGroup

	// 模拟多个映射goroutine并发写入
	words := []string{"length", "colour", "length", "colour", "length"}
	values := []string{"1", "red", "33", "blue", "1"}

	for i, key := range words {
		wg.Add(1)
		go func(k string, v string) {
			defer wg.Done()
			
			// 使用LoadOrStore处理并发写入
			if actual, loaded := result.LoadOrStore(k, []string{v}); loaded {
				// 如果key已存在，追加新值
				existing := actual.([]string)
				updated := append(existing, v)
				result.Store(k, updated)
			}
		}(key, values[i])
	}

	wg.Wait()

	// 归约阶段：处理所有映射结果
	finalResult := make(map[string][]string)
	result.Range(func(key, value interface{}) bool {
		finalResult[key.(string)] = value.([]string)
		return true
	})

	fmt.Printf("Final result: %v\n", finalResult)
}

另一个使用互斥锁和普通Map的替代方案：

package main

import (
	"fmt"
	"sync"
)

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

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

func (m *SafeMap) Append(key string, value string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data[key] = append(m.data[key], value)
}

func (m *SafeMap) GetResult() map[string][]string {
	m.mu.RLock()
	defer m.mu.RUnlock()
	
	// 返回副本避免数据竞争
	result := make(map[string][]string)
	for k, v := range m.data {
		result[k] = append([]string{}, v...)
	}
	return result
}

func main() {
	safeMap := NewSafeMap()
	var wg sync.WaitGroup

	words := []string{"length", "colour", "length", "colour", "length"}
	values := []string{"1", "red", "33", "blue", "1"}

	for i, key := range words {
		wg.Add(1)
		go func(k string, v string) {
			defer wg.Done()
			safeMap.Append(k, v)
		}(key, values[i])
	}

	wg.Wait()

	finalResult := safeMap.GetResult()
	fmt.Printf("Final result: %v\n", finalResult)
}

关于你的队列方案：在Go中引入额外的队列层会增加复杂度且可能成为瓶颈。Go的并发原语（goroutine和channel）已经提供了高效的并发处理机制。使用sync.Map或带互斥锁的Map能够直接安全地处理并发写入，无需队列中间层。

对于MapReduce模式，典型做法是让映射goroutine直接写入共享数据结构，使用适当的同步机制，然后在所有映射完成后进行归约操作。这种方法避免了单点瓶颈，充分利用了Go的并发优势。