要向所有客户端发送消息，您需要在服务器端使用WebSocket连接来管理客户端连接，并使用WebSocket连接实例将消息发送到所有现有客户端。下面是一个简单的示例，它用Go使用Gorilla WebSocket库实现WebSocket服务器和客户端连接。
内存指针转换

            // 创建一个空的 Map
            m := make(map[int64]string)
                ws, err := r.WebSocket()
                if err != nil {
                    glog.Error(ctx, err)
                    r.Exit()
                }

                fmt.Println("original data is", ws)
                // unsafe.Pointer 是内存指针 转换方法
                strPointerHex := fmt.Sprintf("%p", unsafe.Pointer(ws))
                fmt.Println("strPointerHex is", strPointerHex)
                strPointerInt := fmt.Sprintf("%d", unsafe.Pointer(ws))
                fmt.Println("strPointerInt is", strPointerInt)
                // 得到数字用于存储
                int64s, _ := strconv.ParseInt(strPointerInt, 10, 0)
                fmt.Println("int64s is", int64s)
                // var pointer *ghttp.WebSocket
                // pointer = *(**ghttp.WebSocket)(unsafe.Pointer(&int64s))
                // fmt.Println("connection pointer is", pointer)

                // debugMsg := fmt.Sprintf("%p", unsafe.Pointer(pointer))
                // fmt.Println("debugMsg is", debugMsg)
                                m[int64s] = ""
                    for key, value := range m {
                        fmt.Println(key, ":", value)
                        var ws1 *ghttp.WebSocket
                        ws1 = *(**ghttp.WebSocket)(unsafe.Pointer(&key))

                        if err = ws1.WriteMessage(msgType, msg); err != nil {
                            return
                        }
                    }
                                

package main
import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)
// Gorilla WebSocket连接升级器
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}
// 全局客户端map
var clients = make(map[*websocket.Conn]bool)
// 全局广播消息通道
var broadcast = make(chan []byte)
// WebSocket服务器处理程序
func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    // 升级HTTP连接为WebSocket连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    // 连接成功时将客户端添加到全局map
    clients[conn] = true
    defer func() {
        // 连接关闭时从全局map删除客户端
        delete(clients, conn)
        conn.Close()
    }()
    for {
        // 读取消息
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        // 将消息发送到广播通道，以便它可以被广播到所有客户端
        broadcast <- message
    }
}
func main() {
    // 启动WebSocket服务器
    http.HandleFunc("/ws", handleWebSocket)
    go func() {
        err := http.ListenAndServe(":8080", nil)
        if err != nil {
            log.Fatal("ListenAndServe: ", err)
        }
    }()
    //不断处理广播通道上的消息，并向所有客户端发送
    for {
        message := <-broadcast
        for client := range clients {
            err := client.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println(err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

这个简单的示例演示了如何使用Go和Gorilla WebSocket库实现WebSocket服务器，处理新的WebSocket连接，将客户端添加到全局map，从客户端读取消息并广播到所有客户端，以及使用它来向所有客户端发送消息。更新广播消息通道以便消息可以在所有连接的客户端之间传播。

goframe框架来做websocket的server

var (
    // Main is the main command.
    Main = gcmd.Command{
        Name:  "main",
        Usage: "main",
        Brief: "start http server of simple goframe demos",
        Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
            s := g.Server()

            // 创建一个空的 Map
            m := make(map[int64]string)
            // 同时绑定监听 websocket
            s.BindHandler("/ws", func(r *ghttp.Request) {
                ws, err := r.WebSocket()
                if err != nil {
                    glog.Error(ctx, err)
                    r.Exit()
                }
        
                fmt.Println("original data is", ws)
                strPointerHex := fmt.Sprintf("%p", unsafe.Pointer(ws))
                fmt.Println("connection is", strPointerHex)

                strPointerInt := fmt.Sprintf("%d", unsafe.Pointer(ws))
                fmt.Println("connection is", strPointerInt)

                int64s, _ := strconv.ParseInt(strPointerInt, 10, 0)

                // var pointer *ghttp.WebSocket
                // pointer = *(**ghttp.WebSocket)(unsafe.Pointer(&int64s))
                // fmt.Println("connection pointer is", pointer)

                // debugMsg := fmt.Sprintf("%p", unsafe.Pointer(pointer))
                // fmt.Println("debugMsg is", debugMsg)
                m[int64s] = ""
                // 链接参数
                if err = ws.WriteMessage(1, []byte(r.RequestURI)); err != nil {
                    return
                }
                for {
                    msgType, msg, err := ws.ReadMessage()

                    if err != nil {
                        return
                    }
                    m[int64s] = string(msg)
                    for key, value := range m {
                        fmt.Println(key, ":", value)
                        var ws1 *ghttp.WebSocket
                        ws1 = *(**ghttp.WebSocket)(unsafe.Pointer(&key))

                        if err = ws1.WriteMessage(msgType, msg); err != nil {
                            return
                        }
                    }
                    if err = ws.WriteMessage(msgType, []byte("ok")); err != nil {
                        return
                    }
                }
            })
//下面都是http的路由配置 ，如果只需要ws服务 下面可以删除
            s.Use(ghttp.MiddlewareHandlerResponse)
            s.Group("/", func(group *ghttp.RouterGroup) {
                // Group middlewares.
                group.Middleware(
                    service.Middleware().Ctx,
                    ghttp.MiddlewareCORS,
                )
                // 这是 http路由控制器绑定
                group.Bind(
                    user.New(),
                    globaluser.New(),
                )
            })
            s.Run()
            return nil
        },
    }
)