Go 如何向池中的所有连接发送消息

当服务器端事件添加到流中时，如何确保当前连接到该流的所有客户端都接收到该事件，即如何循环所有客户端并在丢弃消息之前向其发送消息，这是否适用于sse和Go

下面总结了我想要实现的伪代码

package main

import (
    "github.com/gin-contrib/sse"
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {

    router := gin.New()
    router.Use(gin.Logger())

    var events = make(chan sse.Event, 100)

    router.GET("/api/addUser/event", func(c *gin.Context) {

        c.Header("Content-Type", "text/event-stream")
        c.Header("Access-Control-Allow-Origin", "*")
        c.Header("Access-Control-Allow-Headers", "access-control-allow-origin, access-control-allow-headers")

        // if events chan has an event
        // Send event to all connected clients

        if( we have events then send them to all clients){

            event := <-events
            _ = sse.Encode(c.Writer, event)
        }

    })

    router.POST("/api/addUser", func(c *gin.Context) {

        //On user add
        //Add event to events chan
        events <- sse.Event{
            Event: "newChiitiko",
            Id:    "1",
            Data:  "New Chiitiko Event",
        }

        c.JSON(http.StatusOK, "okay")
    })

    _ = router.Run(":5000")
}

主程序包
进口(
“github.com/gin contrib/sse”
“github.com/gin gonic/gin”
“net/http”
)
func main（）{
路由器：=gin.New（）
router.Use（gin.Logger（））
var事件=制造（成交量事件，100）
router.GET（“/api/addUser/event”），func（c*gin.Context）{
c、 标题（“内容类型”、“文本/事件流”）
c、 标题（“访问控制允许原点”、“*”）
c、 标题（“访问控制允许标题”、“访问控制允许来源、访问控制允许标题”）
//如果事件chan有一个事件
//向所有连接的客户端发送事件
如果（我们有事件，然后将它们发送给所有客户端）{
事件：=单通道很难做到这一点。最简单的答案是为每个连接创建通道

比如：

mu := new(sync.Mutex)
var eventChans []sse.Event

router.GET("/api/addUser/event", func(c *gin.Context) {
    c.Header("Content-Type", "text/event-stream")
    c.Header("Access-Control-Allow-Origin", "*")
    c.Header("Access-Control-Allow-Headers", "access-control-allow-origin, access-control-allow-headers")

    // Add own channel to the pool.
    events := make(chan sse.Event)
    mu.Lock()
    eventChans = append(eventChans, events)
    mu.Unlock()

    // Listen for the events.
    for(event := range events) {
        sse.Encode(c.Writer, event)
    }
})

router.POST("/api/addUser", func(c *gin.Context) {
    mu.Lock()
    for(_, events := range eventChans) {
        events <- sse.Event{ ... }
    }
    mu.Unlock()

    c.JSON(http.StatusOK, "okay")
})

cond := sync.NewCond(new(sync.Mutex))
var event *sse.Event

router.GET("/api/addUser/event", func(c *gin.Context) {
    c.Header("Content-Type", "text/event-stream")
    c.Header("Access-Control-Allow-Origin", "*")
    c.Header("Access-Control-Allow-Headers", "access-control-allow-origin, access-control-allow-headers")

    for {
        // Wait for event.
        cond.L.Lock()
        for(event == nil) {
            cond.Wait()
        }

        sse.Encode(c.Writer, event)
    }
})

router.POST("/api/addUser", func(c *gin.Context) {
    cond.L.Lock()
    event = sse.Event{ ... }
    cond.L.Unlock()

    cond.Broadcast()

    c.JSON(http.StatusOK, "okay")
})