go - 为什么 gorilla websocket 聊天示例没有发现必须使用 sync.RWMutex 来访问和编辑 map ？

Question

在聊天示例中有一个名为 hub.go 的文件。

https://github.com/gorilla/websocket/blob/master/examples/chat/hub.go

我对该文件做了一些修改，它看起来像这样:

type hub struct {
    // Registered connections.
    connections map[int64]*connection

    sync.RWMutex

    // Inbound messages from the connections.
    broadcast chan []byte

    // Register requests from the connections.
    register chan *connection

    // Unregister requests from connections.
    unregister chan *connection
}

var wsHub = hub{
    connections: make(map[int64]*connection),
    broadcast:   make(chan []byte),
    register:    make(chan *connection),
    unregister:  make(chan *connection),
}

func (h *hub) init() {
    for {
        select {
        case c := <-h.register:
            h.Lock()
            h.connections[c.userId] = c
            h.Unlock()
        case c := <-h.unregister:
            h.RLock()
            _, ok := h.connections[c.userId]
            h.RUnlock()
            if ok {
                h.Lock()
                delete(h.connections, c.userId)
                h.Unlock()
                close(c.send)
            }
        case m := <-h.broadcast:
            for _, c := range h.connections {
                select {
                case c.send <- m:
                default:
                    close(c.send)
                    delete(h.connections, c.userId)
                }
            }
        }
    }
}

我已将 sync.RWMutex 添加到集线器结构，但我不确定是否有必要这样做。为什么它不包含在示例中？也许我错过了什么？锁定和解锁是不是太过分了？

还有 init() 方法中的最后一个案例，我不确定如何锁定和解锁，因为它是同时读取和写入的。我应该同时使用 Rlock() 和 Lock() 吗？那会是什么样子？

Answer 1

不需要互斥锁，因为 single hub goroutine是唯一访问 map 的 goroutine。

另一种方法是消除 Go 例程和 channel ，并用使用互斥锁的函数替换它们。

type hub struct {
  connections map[*connection]bool
  mu sync.Mutex
}

var h = hub{
   connections: make(map[*connection]bool),
}

func (h * hub) register(c *connection) {
  h.mu.Lock()
  h.connections[c] = true
}

func (h *hub) unregister(c *connection) {
  h.mu.Lock()
  if _, ok := h.connections[c]; ok {
     delete(h.connections, c)
     close(c.send)
  }
  h.mu.Unlock()
}

func (h * hub) broadcast(message []byte) {
  h.mu.Lock()
  for c := range h.connections {
    select {
    case c.send <- m:
    default:
      close(c.send)
      delete(h.connections, c)
    }
  }
  h.mu.Unlock()
}

保护很重要close(c.send)和 c.send <- m与互斥体。这可以防止在关闭的 channel 上发送。