golang/%E6%A0%B8%E5%BF%83%E7%9F%A5%E8%AF%86%E7%82%B9/%E5%AE%9E%E7%8E%B0%E9%98%BB%E5%A1%9E%E8%AF%BB%E7%9A%84%E5%B9%B6%E5%8F%91%E5%AE%89%E5%85%A8Map

[giscus[bot]]

golang/%E6%A0%B8%E5%BF%83%E7%9F%A5%E8%AF%86%E7%82%B9/%E5%AE%9E%E7%8E%B0%E9%98%BB%E5%A1%9E%E8%AF%BB%E7%9A%84%E5%B9%B6%E5%8F%91%E5%AE%89%E5%85%A8Map

实现阻塞读且并发安全的map GO里面MAP如何实现key不存在 get操作等待 直到key存在或者超时，保证并发安全，且需要实现以下接口： 解析： 看到阻塞协程第一个想到的就是channel，题目中要求并发安全，那么必须用锁，还要实现多个goroutine读的时候如果值不存在则阻塞，直到写入值，那么每个键值需要有一个阻塞goroutine 的 cha...

https://golangguide.top/golang/%E6%A0%B8%E5%BF%83%E7%9F%A5%E8%AF%86%E7%82%B9/%E5%AE%9E%E7%8E%B0%E9%98%BB%E5%A1%9E%E8%AF%BB%E7%9A%84%E5%B9%B6%E5%8F%91%E5%AE%89%E5%85%A8Map.html

[composer964]

是不是少了rd方法呀

[6adore]

贴一个gpt写的Rd

func (m *Map) Rd(key string, timeout time.Duration) interface{} {
    m.rmx.RLock()
    item, ok := m.c[key]
    if ok && item.isExist {
        defer m.rmx.RUnlock()
        return item.value
    }
    if !ok {
        item = &entry{ch: make(chan struct{})}
        m.c[key] = item
    }
    ch := item.ch
    m.rmx.RUnlock()

    select {
    case <-ch:
        m.rmx.RLock()
        defer m.rmx.RUnlock()
        return item.value
    case <-time.After(timeout):
        return nil
    }
}

[YouZhengChuan]

这个方案有问题吧，如果同时读取多个不存在的key，那么就有多个携程阻塞在m.rmx.RLock()的位置；这个时候如果有其他协程调用Out(key string, val interface{}) 方法，在进入函数后，执行m.rmx.Lock()时，因为m.rmx还有读锁未释放，导致m.rmx.Lock()也会阻塞住。整个程序就会卡住了。。。

[YouZhengChuan]

我上面分析得有问题，实验了下并不会卡住。但是存在map并发写的问题，修复了下：

package main

import (
	"log"
	"sync"
	"time"
)

type Map struct {
	c   map[string]*entry
	rmx *sync.RWMutex
}
type entry struct {
	ch      chan struct{}
	value   interface{}
	isExist bool
}

func NewMap() *Map {
	m := Map{
		c:   make(map[string]*entry),
		rmx: new(sync.RWMutex),
	}
	return &m
}

func (m *Map) Out(key string, val interface{}) {
	m.rmx.Lock()
	defer m.rmx.Unlock()
	item, ok := m.c[key]
	if !ok {
		m.c[key] = &entry{
			value:   val,
			isExist: true,
		}
		return
	}
	item.value = val
	if !item.isExist {
		if item.ch != nil {
			close(item.ch)
			item.ch = nil
		}
	}
	return
}

func (m *Map) Rd(key string, timeout time.Duration) interface{} {
	m.rmx.RLock()
	item, ok := m.c[key]
	if ok && item.isExist {
		defer m.rmx.RUnlock()
		return item.value
	}
	
	m.rmx.RUnlock() // 先释放读锁
	if !ok {
		
		// 修改`m.c`，需要上写锁
		m.rmx.Lock()
		
		item = &entry{ch: make(chan struct{})}
		m.c[key] = item
		
		m.rmx.Unlock()
	}
	ch := item.ch

	select {
	case <-ch:
		log.Println("rlock for key:", key)
		m.rmx.RLock()
		log.Println("rUnlock for key:", key)
		defer m.rmx.RUnlock()
		return item.value
	case <-time.After(timeout):
		return nil
	}
}

func main() {
	m := NewMap()
	wg := new(sync.WaitGroup)

	log.Println("read k1, wait 2sec")
	wg.Add(1)
	go func() {
		defer wg.Done()

		v := m.Rd("k1", time.Second*2)
		log.Println("k1 = ", v)
	}()

	log.Println("read k2, wait 3sec")
	wg.Add(1)
	go func() {
		defer wg.Done()

		v := m.Rd("k2", time.Second*3)
		log.Println("k2 = ", v)
	}()
	time.Sleep(time.Millisecond * 200)

	log.Println("set k3")
	m.Out("k3", 2333)
	v := m.Rd("k3", time.Second)
	log.Println("after set k3, k3 = ", v)
	m.Out("k3", 2334)
	v = m.Rd("k3", time.Second)
	log.Println("after set k3, k3 = ", v)
	
	wg.Wait()
}