Go-线程安全Map

type RWSafeMap struct {
	sync.RWMutex // 使用读写锁
	m map[string]int
}

func NewRWSafeMap(len int) *RWSafeMap {
	return &RWSafeMap{
		m: make(map[string]int, len),
	}
}

func (m *RWSafeMap) Store(key string, value int) {
	m.Lock()
	defer m.Unlock()
	m.m[key] = value
}

func (m *RWSafeMap) Load(key string) (int, bool) {
	m.RLock()
	defer m.RUnlock()
	value, ok := m.m[key]
	return value, ok
}

func (m *RWSafeMap) Delete(key string) {
	m.Lock()
	defer m.Unlock()
	delete(m.m, key)
}

func (m *RWSafeMap) Len() int {
	m.RLock()
	defer m.RUnlock()
	return len(m.m)
}

func testRWSafeMap() {
	num := 100
	safeMap := NewRWSafeMap(num)
	waitGroup := sync.WaitGroup{}
	waitGroup.Add(num)
	for i := 0; i < num; i++ {
		go func(num int) {
			defer waitGroup.Done()
			safeMap.Store(fmt.Sprintf("%d", num), num)
		}(i)
	}
	waitGroup.Wait()
	fmt.Println(safeMap.Len()) // 100
}

func testSyncMap() {
	var syncMap sync.Map
	waitGroup := sync.WaitGroup{}
	waitGroup.Add(100)
	for i := 0; i < 100; i++ {
		go func(num int) {
			defer waitGroup.Done()
			syncMap.Store(fmt.Sprintf("%d", num), num) // 添加键值对
		}(i)
	}
	waitGroup.Wait()
	var sum = 0
	// 遍历map
	syncMap.Range(func(key, value any) bool {
		str := key.(string)
		num := value.(int)
		fmt.Printf("key=%s\tvalue=%d\n", str, num)
		sum++
		return true
	})
	fmt.Println(sum)

	// 通过key获得value
	value, ok := syncMap.Load("50")
	fmt.Println(value, ok)
	// 删除键值对
	syncMap.Delete("1")
}

type Map struct {
	mu Mutex // 互斥锁、用来保护 read和dirty字段
	
	read atomic.Value // 本质上也是个原生的map，支持并发的读取，其他操作则通过加锁来保证线程安全

	dirty map[any]*entry // 包含需要加锁才能访问的元素，包括在read字段中不存在的键值对

	misses int // 记录从read中miss的次数，当miss数和dirty长度一样时，则会把dirty提升为read
}

type readOnly struct {
	m       map[any]*entry
	amended bool // dirty是否包含read不存在的数据
}

// entry代表一个值
type entry struct {
    p unsafe.Pointer // *interface{}
}

func (m *Map) Store(key, value any) {
	read, _ := m.read.Load().(readOnly) // 获得只读map
	if e, ok := read.m[key]; ok && e.tryStore(&value) { // 如果对应key存在、则尝试通过CAS更新值
		return
	}
    // 否则加锁，进行操作
	m.mu.Lock()
	read, _ = m.read.Load().(readOnly)
	if e, ok := read.m[key]; ok {
		if e.unexpungeLocked() {
			// 如果已经该键值对已被删除则添加到dirty中
			m.dirty[key] = e
		}
		e.storeLocked(&value) // 更新值
	} else if e, ok := m.dirty[key]; ok { // 如果dirty存在该键值对则直接更新
		e.storeLocked(&value) 
	} else {
	    // 如果都不存在则是新key
		if !read.amended {
	        // 创建一个dirty
			m.dirtyLocked()
			m.read.Store(readOnly{m: read.m, amended: true})
		}
		m.dirty[key] = newEntry(value) // 将值存放进dirty中
	}
	m.mu.Unlock()
}

func (m *Map) Load(key any) (value any, ok bool) {
	read, _ := m.read.Load().(readOnly)
	e, ok := read.m[key]
	if !ok && read.amended { // 如果read中不存在该键值对，同时dirty有额外的值
		m.mu.Lock()
		read, _ = m.read.Load().(readOnly) // 双重判断一下，提高性能
		e, ok = read.m[key]
		if !ok && read.amended { 
			e, ok = m.dirty[key]
			m.missLocked() // 核心方法
		}
		m.mu.Unlock()
	}
	if !ok {
		return nil, false
	}
	return e.load()
}

func (m *Map) missLocked() {
	m.misses++
	if m.misses < len(m.dirty) { 
		return
	}
	// 如果misses等于dirty的长度，则将dirty提升为read，并将原来的dirty设为nil
	m.read.Store(readOnly{m: m.dirty})
	m.dirty = nil
	m.misses = 0
}