客户端同步中的竞争条件

Golang不知道大家是否熟悉？今天我将给大家介绍《客户端同步中的竞争条件》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

我有一个网络应用程序，其服务器为每个 websocket 连接创建一个客户端。客户端充当 websocket 连接和 Hub 的单个实例之间的中介。集线器维护一组已注册的客户端并向客户端广播消息。这工作得很好，但问题是客户端可能会错过服务器生成客户端在连接上接收的初始状态包和客户端向集线器注册并开始接收广播事件之间的事件。

我的想法是在从数据库获取任何信息之前向集线器注册客户端。这将确保客户端不会错过任何广播，尽管现在它可以接收已应用于其接收的初始状态的消息。为了允许客户端忽略这些消息，我可以在初始状态包和广播事件中包含单调时间戳。

你能想出一个更优雅/更简单的解决方案吗？

解决方案

我过去曾使用预写日志来执行类似的操作。简而言之，在集线器中保留一个消息环形缓冲区。然后重播在新客户端初始化时发送到现有客户端的消息。

如果您愿意，您也可以向客户展示这个概念。这样您就可以实现高效的重新连接（特别适合移动连接）。当客户端断开 websocket 连接时，他们可以重新连接并说“嘿，又是我。看起来我们被中断了。我看到的最后一条消息是 42 号。有什么新消息吗？”

以下内容来自记忆，因此仅作为想法的说明，而不是完成的实现。例如，为了简洁起见，我省略了 client.send 周围的选择语句。

package main

import (
    "container/list"
    "sync"

    "github.com/gorilla/websocket"
)

type Client struct { // all unchanged
    hub  *Hub
    conn *websocket.Conn
    send chan []byte
}

type Hub struct {
    mu      *sync.RWMutex
    wal     list.List        // List if recent messages
    clients map[*Client]bool // Registered clients.

    register chan Registration // not a chan *Client anymore

    broadcast  chan []byte
    unregister chan *Client
}

type Registration struct {
    client *Client

    // init is a function that is executed before the client starts to receive
    // broadcast messages. All messages that are broadcast while init is
    // running will be sent after init returns.
    init func()
}

func (h *Hub) run() {
    for {
        select {
        case reg := <-h.register:
            // Take note of the most recent message as of right now. 
            // initClient will replay all later messages
            h.mu.RLock()
            head := h.wal.Back()
            h.mu.RUnlock()

            go h.initClient(reg, head)
        case client := <-h.unregister:
            h.mu.Lock()
            if _, ok := h.clients[client]; ok {
                delete(h.clients, client)
                close(client.send)
            }
            h.mu.Unlock()
        case message := <-h.broadcast:
            h.mu.Lock()
            h.wal.PushBack(message)
            // TODO: Trim list if too long by some metric (e.g. number of
            // messages, age, total message size, etc.)

            clients := make([]*Client, len(h.clients))
            copy(clients, h.clients)
            h.mu.Unlock()

            for client := range clients {
                // TODO: deal with backpressure
                client.send <- message
            }
        }
    }
}

func (h *Hub) initClient(reg Registration, head *list.Element) {
    reg.init()

    // send messages in h.wal after head
    for {
        h.mu.RLock()
        head = head.Next()
        if head == nil {
            // caught up
            h.clients[reg.client] = true
            h.mu.RUnlock()
            return
        }
        h.mu.RUnlock()

        // TODO: deal with backpressure
        reg.client.send <- head.Value.([]byte)
    }
}

好了，本文到此结束，带大家了解了《客户端同步中的竞争条件》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！