go websocket推送优化

ws推送优化

1、写多读少的情况，使用epoll 避免创建读的协程。

2、分片存储连接，降低锁的粒度，提高推送的并发。

3、写的时候使用缓存，批量定时写入，减少系统调用、协程的调度。

4、直接使用tcp连接升级。

5、零拷贝。

1、epoll

1、实现参考，https://github.com/eranyanay/1m-go-websockets 只适用在写多读少的情况下，并且读之后的业务耗时的操作不要太频繁。

https://github.com/eranyanay/1m-go-websockets/blob/master/3_optimize_ws_goroutines/server.go 这里读的时候要考虑到半消息的情况，https://studygolang.com/topics/13377 当收到websocket数据包不全的情况下，go net官方库当不可读的时候是会阻塞的。

我自己写的一个测试 github.com/gobwas/ws 提供了非常灵活的用法我们可以可以直接将一个websocket数据包转为字节。

func main() { {
     dialer := gws.DefaultDialer
     conn, _, _, err := dialer.Dial(context.Background(), "ws://10.18.13.129:8989/ws")
     if err != nil {
        log.Fatalln("err", err)
    }

     message := NewMessage(gws.OpText, []byte("abcdefjhigklmnopqrusasdflsdfasdl"))
     b, _ := message.ToBytes()
     conn.Write(b[:5])
     log.Println("发送前5个字节")
     time.Sleep(time.Second * 3)
     conn.Write(b[5:])
     log.Println("发送后面的字节")

     select {}
 }

   type Message struct {
    messageType gws.OpCode
    data        []byte
}

func NewMessage(code gws.OpCode, data []byte) Message {
    return Message{
        messageType: code,
        data:        data,
    }
}
func (m Message) ToBytes()([]byte, error) {
    var res bytes.Buffer
    frame := gws.NewFrame(m.messageType, true, m.data)
    if err := gws.WriteFrame(&res, frame); err != nil {
        return nil, err
    }
    return res.Bytes(), nil
}
2023/04/18 18:09:55 发送前5个字节
2023/04/18 18:09:58 发送后面的字节

func main() {
    engine := gin.New()
    engine.GET("/ws", Connect)
    engine.Run(":8989")
}
func Connect(c *gin.Context) {
    var httpUpgrade gws.HTTPUpgrader
    conn, _, _, err := httpUpgrade.Upgrade(c.Request, c.Writer)
    if err != nil {
       return
   }

    if err != nil {
       return
   }
     frame, err := gws.ReadFrame(conn)
       if err != nil {
          log.Println("err", err)
          return
      }
    log.Println(string(frame.Payload))
    //最终要等到数据全部到，go net官方库当不可读的时候是阻塞的。
   2023/04/18 18:09:58 abcdefjhigklmnopqrusasdflsdfasdl

}

解决方法：使用syscall.Read读取，如果没有读完一整条websocket消息的话，就缓存起来，不阻塞，读的起始位置就回退到上次读出完整数据的位置，这里需要自己diy bufio.Reader 缓存没有读完的消息。

2、使用写缓存

如果在小包特别多得情况下，直接发送会有很多系统调用,gmp模型，每一次系统调用go都会有一次调度 会消耗cpu。pprof分析，也是system.write占用cpu比较高，在实时性要求不高的情况下，我们可以批量定时写入。

得益于github.com/gobwas/ws 提供的非常灵活的用法，我们可以暂时将我们要写的数据转为websocket数据包缓存起来。批量定时写入

 type Message struct {
    messageType gws.OpCode
    data        []byte
}
func (m Message) ToBytes()([]byte, error) {
    var res bytes.Buffer
    frame := gws.NewFrame(m.messageType, true, m.data)
    if err := gws.WriteFrame(&res, frame); err != nil {
        return nil, err
    }
    return res.Bytes(), nil
}
for {
    select {
       case data := <-conn.write:
       if _, err := conn.writeBuf.Write(data); err != nil {
          return
      }
      //writeBuf 为*bufio.Writer。
       case <-conn.writeRate.C:

       //写到连接中
       if conn.writeBuf.Available() > 0 {
          if err := conn.writeBuf.Flush(); err != nil {
             return
         }
      }

   }
}

3、分片存储连接

主要是参考https://github.com/owenliang/go-push

主要的思路是分区存储连接，降低锁的粒度和推送的并发度。

4、零拷贝

在大包多的情况是使用零拷贝，好像也会提高性能。

https://zhuanlan.zhihu.com/p/308054212

https://mp.weixin.qq.com/s/wSaJYg-HqnYY4SdLA2Zzaw

5、基于tcp升级

github.com/gobwas/ws 也有直接基于tcp升级的用法，避免http分配的4k读缓存。

6、具体代码

具体代码仓库地址 github.com/luxun9527/gpush 练习时长还没到两年半，还有很多不完善的地方主要是提供一个实现的思路 如果对您有帮助，请帮我点一下star。