多房间的聊天室（七）优雅地处理用户下线与移除房间时的情况

后端

2023-09-29 10:30:46

前言

上一篇文章中，我们讨论了如何通过引入锁来解决并发问题，保障聊天室的稳定运行。然而，在实际应用中，我们还会遇到一些棘手的问题，比如：

map 并发冲突问题 ：多个 goroutine 同时对同一个 map 进行操作，可能导致数据不一致的情况。
房间锁过多导致内存逐步增长的问题 ：每个房间都有一个锁，随着房间数量的增加，锁的数量也会不断增加，导致内存逐步增长。

本文将重点讨论上述两个问题，并提出解决方案。

解决 map 并发冲突问题

在上一篇文章中，我们使用了锁来保护对 map 的操作，但这种方式可能会导致性能下降。为了解决这个问题，我们可以使用并发安全的 map。

Go 语言提供了 sync.Map 类型，它是一个并发安全的 map，可以同时被多个 goroutine 访问。sync.Map 的使用方法与普通 map 类似，但它提供了一些额外的功能，比如：

Load() 方法：以只读方式获取 map 中的值。
Store() 方法：以写入方式将键值对添加到 map 中。
Delete() 方法：从 map 中删除键值对。

使用 sync.Map 可以有效地解决 map 并发冲突问题。

解决房间锁过多导致内存逐步增长的问题

在上一篇文章中，我们为每个房间创建了一个锁，用来保护对房间数据的访问。随着房间数量的增加，锁的数量也会不断增加，导致内存逐步增长。

为了解决这个问题，我们可以使用一个全局锁来保护对所有房间数据的访问。这种方式可以减少锁的数量，降低内存使用率。

具体来说，我们可以创建一个全局的 sync.Mutex 类型的锁，并使用这个锁来保护对所有房间数据的访问。当一个 goroutine 需要访问某个房间的数据时，它需要先获取这个全局锁，然后才能访问房间数据。当访问完成之后，它需要释放这个全局锁。

使用全局锁可以有效地减少锁的数量，降低内存使用率。但是，这种方式可能会导致性能下降。这是因为，当多个 goroutine 同时需要访问房间数据时，它们需要排队等待获取全局锁，这可能会导致性能下降。

为了解决这个问题，我们可以使用一个更细粒度的锁机制。我们可以为每个房间创建一个锁，但只在需要的时候才使用这个锁。当一个 goroutine 需要访问某个房间的数据时，它需要先检查这个房间是否已经被锁定。如果房间已经锁定，则 goroutine 需要等待，直到房间解锁后才能访问房间数据。如果房间没有被锁定，则 goroutine 可以直接访问房间数据。

使用这种更细粒度的锁机制，可以减少锁的争用，提高性能。

优雅地处理用户下线与移除房间时的情况

在实际应用中，用户可能会下线或被移除房间。当用户下线或被移除房间时，我们需要优雅地处理这种情况。

当用户下线时，我们需要从所有房间中删除该用户。我们可以遍历所有房间，检查每个房间中是否有该用户，如果有，则将该用户从房间中删除。

当用户被移除房间时，我们需要从该房间中删除该用户。我们可以获取该房间的锁，然后将该用户从房间中删除。当删除完成后，我们需要释放该房间的锁。

死锁问题

在解决上述问题的过程中，我们可能会遇到经典的死锁问题。死锁是指两个或多个进程互相等待对方释放资源，导致所有进程都无法继续执行的情况。

在我们的例子中，死锁可能发生在以下情况下：

goroutine A 需要获取房间 A 的锁，但房间 A 的锁已经被 goroutine B 持有。
goroutine B 需要获取房间 B 的锁，但房间 B 的锁已经被 goroutine A 持有。

在这种情况下，goroutine A 和 goroutine B 都无法继续执行，导致死锁。

为了避免死锁，我们可以使用以下策略：

使用超时机制：当一个 goroutine 获取锁时，我们可以设置一个超时时间。如果在超时时间内 goroutine 无法获取锁，则 goroutine 会放弃获取锁并继续执行。
使用死锁检测机制：我们可以使用死锁检测机制来检测死锁的发生。当死锁发生时，我们可以强制释放锁，让 goroutine 继续执行。

最终实现

以下是最终实现的代码：

package main

import (
	"sync"
	"time"

	"github.com/gorilla/websocket"
)

// Room represents a chat room.
type Room struct {
	// Mutex to protect the room.
	mu sync.Mutex

	// Name of the room.
	name string

	// Users in the room.
	users map[string]*User

	// Messages sent in the room.
	messages []string
}

// User represents a chat user.
type User struct {
	// Name of the user.
	name string

	// WebSocket connection of the user.
	conn *websocket.Conn

	// Rooms that the user is in.
	rooms map[string]*Room
}

// NewRoom creates a new chat room.
func NewRoom(name string) *Room {
	return &Room{
		name:    name,
		users:   make(map[string]*User),
		messages: make([]string, 0),
	}
}

//AddUser adds a user to the room.
func (r *Room) AddUser(user *User) {
	r.mu.Lock()
	defer r.mu.Unlock()

	r.users[user.name] = user
}

//RemoveUser removes a user from the room.
func (r *Room) RemoveUser(user *User) {
	r.mu.Lock()
	defer r.mu.Unlock()

	delete(r.users, user.name)
}

//SendMessage sends a message to the room.
func (r *Room) SendMessage(message string) {
	r.mu.Lock()
	defer r.mu.Unlock()

	r.messages = append(r.messages, message)
}

// GetMessages returns the messages sent in the room.
func (r *Room) GetMessages() []string {
	r.mu.Lock()
	defer r.mu.Unlock()

	return r.messages
}

// NewUser creates a new chat user.
func NewUser(name string, conn *websocket.Conn) *User {
	return &User{
		name: name,
		conn: conn,
		rooms: make(map[string]*Room),
	}
}

// JoinRoom joins a user to a room.
func (u *User) JoinRoom(room *Room) {
	u.rooms[room.name] = room
	room.AddUser(u)
}

// LeaveRoom leaves a user from a room.
func (u *User) LeaveRoom(room *Room) {
	delete(u.rooms, room.name)
	room.RemoveUser(u)
}

// SendMessage sends a message to a room.
func (u *User) SendMessage(room *Room, message string) {
	room.SendMessage(message)
}

// GetMessages returns the messages sent in a room.
func (u *User) GetMessages(room *Room) []string {
	return room.GetMessages()
}

func main() {
	// Create a new chat room.
	room := NewRoom("room1")

	// Create a new chat user.
	user := NewUser("user1", nil)

	// Join the user to the room.
	user.JoinRoom(room)

	// Send a message to the room.
	user.SendMessage(room, "Hello, world!")

	// Get the messages sent in the room.
	messages := user.GetMessages(room)

	// Print the messages.
	for _, message := range messages {
		fmt.Println(message)
	}
}