func (cmap *ShardedConcurrentMap) Put(key string, value interface{}) {
	shard := cmap.getShard(key)
	shard.Lock()
	cmap.lazyInitShard(shard)
	shard.items[key] = value
	atomic.AddInt32(&cmap.size, 1)
	shard.Unlock()
}
Put records the given key value mapping. Overwrites previous values
package common
import (
	"sync"
	"sync/atomic"
)
const (
	nShards = 32
)
type (
	HashFunc func(string) uint32
	ConcurrentMap interface {
		Get(key string) (interface{}, bool)
		Contains(key string) bool
		Put(key string, value interface{})
		PutIfNotExist(key string, value interface{}) bool
		Remove(key string)
		Iter() MapIterator
		Size() int
	}
	MapIterator interface {
		Close()
		Entries() <-chan *MapEntry
	}
	MapEntry struct {
		Key string
		Value interface{}
	}
	ShardedConcurrentMap struct {
		shards     [nShards]mapShard
		hashfn     HashFunc
		size       int32
		initialCap int
	}
	mapIteratorImpl struct {
		stopCh chan struct{}
		dataCh chan *MapEntry
	}
	mapShard struct {
		sync.RWMutex
		items map[string]interface{}
	}
)
func NewShardedConcurrentMap(initialCap int, hashfn HashFunc) ConcurrentMap {
	cmap := new(ShardedConcurrentMap)
	cmap.hashfn = hashfn
	cmap.initialCap = MaxInt(nShards, initialCap/nShards)
	return cmap
}
func (cmap *ShardedConcurrentMap) Get(key string) (interface{}, bool) {
	shard := cmap.getShard(key)
	var ok bool
	var value interface{}
	shard.RLock()
	if shard.items != nil {
		value, ok = shard.items[key]
	}
	shard.RUnlock()
	return value, ok
}
func (cmap *ShardedConcurrentMap) Contains(key string) bool {
	_, ok := cmap.Get(key)
	return ok
}