用metux lock for循环,在for循环中又 向带缓冲的Channel 写数据时,千万要小心死锁!


有一个作者:https://wavded.com/post/golang-deadlockish/ 分享了一个类似的问题。下面是引用的部分正文内容。
func (r *Room) Broadcast(msg string) { r.membersMx.RLock() defer r.membersMx.RUnlock() for _, m := range r.members { if err := s.Send(msg); err != nil { // ? log.Printf("Broadcast: %v: %v", r.instance, err) } }}请注意,我们等待?,直到每个成员收到消息,然后再继续下一个成员。这很快就会成为问题。
func (r *Room) Add(s sockjs.Session) { r.membersMx.Lock() // ? r.members = append(r.members, s) r.membersMx.Unlock()}我们无法获得锁?,因为我们的 Broadcast 函数仍在使用它来发送消息。

func (ud *UserDevice) SendMsg(ctx context.Context, msg *InternalWebsocketMessage) { // 注意,不是原生的Write if err = ud.Conn.Write(data); err != nil { ud.L.Debug("Write error", zap.Error(err)) }} func (c *connectionImpl) Write(data []byte) (err error) { wsMsgData := &MsgData{ MessageType: websocket.BinaryMessage, Data: data, } c.writer <- wsMsgData // 注意这里,writer是有缓冲的,数量目前是10,如果被写满,就会阻塞 return}
func (m *userManager) BroadcastMsgToRoom(ctx context.Context, msg *InternalWebsocketMessage, roomId []int64) { // 这里有互斥锁,确保map的遍历 m.RLock() defer m.RUnlock() // m.users 是一个 map[int64]User类型 for _, user := range m.users { user.SendMsg(ctx, msg) // ? }}
func (m *userManager) Add(device UserDeviceInterface) (User, int) { uid := device.UID() m.Lock() // ? defer m.Unlock() user, ok := m.users[uid] if !ok { user = NewUser(uid, device.GetLogger()) m.users[uid] = user } remain := user.AddDevice(device) return user, remain}
func onWSUpgrade(ginCtx *gin.Context) { // ... utils.GoSafe(ctx, func(ctx context.Context) { // ... userDevice.User, remain = biz.DefaultUserManager.Add(userDevice) }, logger)}
但是 c.writer <- wsMsgData 为什么会满了呢?再继续跟代码,发这里原来有个超时逻辑:
func (c *connectionImpl) ExecuteLogic(ctx context.Context, device UserDeviceInterface) { go func() { for { select { case msg, ok := <-c.writer: if !ok { return } // 写超时5秒 _ = c.conn.SetWriteDeadline(time.Now().Add(types.KWriteWaitTime)) if err := c.conn.WriteMessage(msg.MessageType, msg.Data); err != nil { c.conn.Close() c.onWriteError(err, device.UserId(), device.UserId()) return } } } }()}这下就能解释的通了!
// Push server push message.func (c *Channel) Push(p *protocol.Proto) (err error) { select { case c.signal <- p: default: err = errors.ErrSignalFullMsgDropped } return}
有一个select,发现了吗?如果c.signal缓冲区满,这个i/o就被阻塞,select轮询机制会执行到default,那么调用方在循环中调用Push的时候,也不会block了。
func (c *connectionImpl) Write(data []byte) (err error) { wsMsgData := &MsgData{ MessageType: websocket.BinaryMessage, Data: data, } // if buffer full, return error immediate select { case c.writer <- wsMsgData: default: err = ErrWriteChannelFullMsgDropped } return}func main() { w := make(chan string, 2) w <- "1" fmt.Println("write 1") w <- "2" fmt.Println("write 2”) w <- "3"}
write 1write 2fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan send]:main.main() /Users/xu/repo/github/01_struct_mutex/main.go:133 +0xdcexit status 2
func main() { w := make(chan string, 2) w <- "1" fmt.Println("write 1") w <- "2" fmt.Println("write 2") select { case w <- "3": fmt.Println("write 3") default: fmt.Println("msg flll") }}
write 1write 2msg flll
用metux lock for循环,在for循环中又 向带缓冲的Channel 写数据时,千万要小心死锁!
func (r *Room) Broadcast(msg string) { r.mu.RLock() defer r.mu.RUnlock() for _, m := range r.members { r.writer <- msg // Bad }}func (r *Room) Broadcast(msg string) { r.mu.RLock() defer r.mu.RUnlock() for _, m := range r.members { // Good?? select { case c.writer <- wsMsgData: default: fmt.Println(“ErrWriteChannelFullMsgDropped”) } }}
——————传说中的分割线——————
大家好,我目前已从C++后端转型为Golang后端,可以订阅关注下《Go和分布式IM》公众号,获取一名转型萌新Gopher的心路成长历程和升级打怪技巧。