一次生产环境高效利用Go Concurrent Map的记录

// 未初始化报错
var m map[string]string
m["a"] = "a"
// 初始化
m := make(map[string]string)

type RWMap struct {
	sync.RWMutex
	safeMap map[string]string
}

func NewRWMap(n int) *RWMap {
	return &RWMap{
		safeMap: make(map[string]string, n),
	}
}

func (m *RWMap) Get(key string) (string, bool) {
	m.RLock()
	defer m.RUnlock()
	val, exists := m.safeMap[key]
	return val, exists
}

func (m *RWMap) Set(key,val string)  {
	m.Lock()
	defer m.Unlock()
	m.safeMap[key] = val
}

func (m *RWMap) Del(key string)  {
	m.Lock()
	defer m.Unlock()
	delete(m.safeMap,key)
}

The Map type is optimized for two common use cases: 
(1) when the entry for a given key is only ever written once but read many times, as in caches that only grow, or
(2) when multiple goroutines read, write, and overwrite entries for disjoint sets of keys. In these two cases, use of a Map may significantly reduce lock contention compared to a Go map paired with a separate Mutex or RWMutex.

https://github.com/orcaman/concurrent-map

var SHARD_COUNT = 32

// A "thread" safe map of type string:Anything.
// To avoid lock bottlenecks this map is dived to several (SHARD_COUNT) map shards.
type ConcurrentMap []*ConcurrentMapShared

// A "thread" safe string to anything map.
type ConcurrentMapShared struct {
	items        map[string]interface{}
	sync.RWMutex // Read Write mutex, guards access to internal map.
}

// Creates a new concurrent map.
func New() ConcurrentMap {
	m := make(ConcurrentMap, SHARD_COUNT)
	for i := 0; i < SHARD_COUNT; i++ {
		m[i] = &ConcurrentMapShared{items: make(map[string]interface{})}
	}
	return m
}

// GetShard returns shard under given key
func (m ConcurrentMap) GetShard(key string) *ConcurrentMapShared {
	return m[uint(fnv32(key))%uint(SHARD_COUNT)]
}

// Sets the given value under the specified key.
func (m ConcurrentMap) Set(key string, value interface{}) {
	// Get map shard.
	shard := m.GetShard(key)
	shard.Lock()
	shard.items[key] = value
	shard.Unlock()
}