使用Go基于WebSocket构建千万级视频直播弹幕系统的代码详解

 更新时间:2022年04月28日 17:04:26   作者:BlueMiaomiao  
这篇文章主要介绍了使用Go基于WebSocket构建千万级视频直播弹幕系统,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

(1)业务复杂度介绍

开门见山,假设一个直播间同时500W人在线,那么1秒钟1000条弹幕,那么弹幕系统的推送频率就是: 500W * 1000条/秒=50亿条/秒 ,想想B站2019跨年晚会那次弹幕系统得是多么的NB,况且一个大型网站不可能只有一个直播间!

使用Go做WebSocket开发无非就是三种情况:

  • 使用Go原生自带的库,也就是 golang.org/x/net ,但是这个官方库真是出了奇Bug多
  • 使用GitHub大佬 gorilla/websocket 库,可以结合到某些Web开发框架,比如Gin、iris等,只要使用的框架式基于 golang.org/net 的,那么这个库就可以与这个框架结合
  • 手撸一个WebSocket框架

根据估算结果,弹幕推送量很大的时候,Linux内核将会出现瓶颈,因为Linux内核发送TCP包的时候极限包发送频率是100W。因此可以将同一秒内的弹幕消息合并为1条推送,减少网络小数据包的发送,从而降低推送频率。

弹幕系统需要维护在线的用户长连接来实现定向推送到在线的用户,通常是使用Hash字典结构,通常推送消息就是遍历在线用的Hash字典。在弹幕推送期间用户在不断的上下线,为了维护上线用户,那么就得不断的修改Hash字典,不断地进行锁操作,用户量过大导致锁瓶颈。因此可以将整个Hash结构拆分为多个Hash结构,分别对多个Hash结构加不同的锁,并且使用读写锁替代互斥锁。

通常服务器与客户端交互使用JSON结构,那么需要不断的编码解码JSON数据,这将会导致CPU瓶颈。将消息先进行合并,然后进行编码,最后轮询Hash结构进行推送。

以上是单体架构存在的问题,为了支持更多的用户负载,通常弹幕系统采用分布式架构,进行弹性扩容缩容。

(2)推送还是拉取?

如果是客户端拉取服务器端数据,那么将会存在以下几个问题:

  • 直播在线人数多就意味着消息数据更新频率高,拉取消息意味着弹幕无法满足时效性
  • 如果很多客户端同时拉取,那么服务器端的压力无异于DDOS
  • 一个弹幕系统应该是通用的,因此对于直播间弹幕较少的场景,意味着消息数据拉取请求都是无效的

因此我们考虑推送模式:当数据发生更新的时候服务器端主动推送到客户端,这样可以有效减少客户端的请求次数。如果需要实现消息推送,那么就意味着服务器端维护大量的长连接。

(3)为什么使用WebSocket?

实现弹幕消息的实时更新一定是使用Socket的方式,那么为啥要使用WebSocket呢?现在大部分直播应用的开发都是跨平台的,然而跨平台的开发框架本质就是Web开发,那么一定离不开WebSocket,而且一部分用户会选择在Web端看视频,比如Bilibili,现如今也有一些桌面应用是用Electron等跨平台框架开发的,比如Lark飞书等,因此实现消息推送的最佳方案就是使用WebSocket。

使用WebSocket可以轻松的维持服务器端长连接,其次WebSocket是架构在HTTP协议之上的,并且也可以使用HTTPS方式,因此WebSocket是可靠传输,并且不需要开发者关注底层细节。

为啥要使用Go搞WebSocket呢?首先说到WebSocket你可能会想到Node.js,但是Node.js是单线程模型,如果实现高并发,不得不创建多个Node.js进程,但是这又不容易服务端遍历整个连接集合;如果使用Java就会显得比较笨重,Java项目的部署,编写Dockerfile都不如Go的目标二进制更加简洁,并且Go协程很容易实现高并发,上一章说到Go语言目前也有成熟的WebSocket轮子。

(4)服务端基本Demo

首先搭建好一个框架:

package main
import (
  "fmt"
  "net/http"
)
func main() {
 fmt.Println("Listen localhost:8080")
   // 注册一个用于WebSocket的路由,实际业务中不可能只有一个路由
  http.HandleFunc("/messages", messageHandler)
  // 监听8080端口,没有实现服务异常处理器,因此第二个参数是nil
  http.ListenAndServe("localhost:8080", nil)
}
func messageHandler(response http.ResponseWriter, request *http.Request) {
  // TODO: 实现消息处理
  response.Write([]byte("HelloWorld"))
}

然后完善messageHandler函数:

func messageHandler(response http.ResponseWriter, request *http.Request) {
  var upgrader = websocket.Upgrader{
    // 允许跨域
    CheckOrigin: func(resquest *http.Request) bool {
      return true
    },
  }
  // 建立连接
  conn, err := upgrader.Upgrade(response, request, nil)
  if err != nil {
    return
  }
  // 收发消息
  for {
    // 读取消息
    _, bytes, err := conn.ReadMessage()
    if err != nil {
      _ = conn.Close()
    }
    // 写入消息
    err = conn.WriteMessage(websocket.TextMessage, bytes)
    if err != nil {
      _ = conn.Close()
    }
  }
}

现在基本上实现了WebSocket功能,但是websocket的原生API不是线程安全的(Close方法是线程安全的,并且是可重入的),并且其他模块无法复用业务逻辑,因此进行封装:

  • 封装Connection对象描述一个WebSocket连接
  • 为Connection对象提供线程安全的关闭、接收、发送API
// main.go
package main
import (
  "bluemiaomiao.github.io/websocket-go/service"
  "fmt"
  "net/http"
  "github.com/gorilla/websocket"
)
func main() {
  fmt.Println("Listen localhost:8080")
  http.HandleFunc("/messages", messageHandler)
  _ = http.ListenAndServe("localhost:8080", nil)
}
func messageHandler(response http.ResponseWriter, request *http.Request) {
  var upgrader = websocket.Upgrader{
    // 允许跨域
    CheckOrigin: func(resquest *http.Request) bool {
      return true
    },
  }
  // 建立连接
  conn, err := upgrader.Upgrade(response, request, nil)
  wsConn, err := service.Create(conn)
  if err != nil {
    return
  }
  // 收发消息
  for {
    // 读取消息
    msg, err := wsConn.ReadOne()
    if err != nil {
      wsConn.Close()
    }
    // 写入消息
    err = wsConn.WriteOne(msg)
    if err != nil {
      _ = conn.Close()
    }
  }
}
// service/messsage_service.go
package service
import (
  "errors"
  "github.com/gorilla/websocket"
  "sync"
)
// 封装的连接对象
// 
// 由于websocket的Close()方法是可重入的,所以可以多次调用,但是关闭Channel的close()
// 方法不是可重入的,因此通过isClosed进行判断
// isClosed可能发生资源竞争,因此通过互斥锁避免
// 关闭websocket连接后,也要自动关闭输入输出消息流,因此通过signalCloseLoopChan实现
type Connection struct {
  conn                  *websocket.Conn  // 具体的连接对象
  inputStream             chan []byte       // 输入流,使用Channel模拟
  outputStream           chan []byte       // 输出流,使用chaneel模拟
  signalCloseLoopChan     chan byte       // 关闭信号
  isClosed               bool            // 是否调用过close()方法
  lock                   sync.Mutex      // 简单的锁
}
// 用于初始化一个连接对象
func Create(conn *websocket.Conn) (connection *Connection, err error) {
  connection = &Connection{
    conn:              conn,
    inputStream:        make(chan []byte, 1000),
    outputStream:       make(chan []byte, 1000),
    signalCloseLoopChan: make(chan byte, 1),
    isClosed:            false,
  }
  // 启动读写循环
  go connection.readLoop()
  go connection.writeLoop()
  return
}
// 读取一条消息
func (c *Connection) ReadOne() (msg []byte, err error) {
  select {
  case msg = <-(*c).inputStream:
  case <-(*c).signalCloseLoopChan:
    err = errors.New("connection is closed")
  }
  return
}
// 写入一条消息
func (c *Connection) WriteOne(msg []byte) (err error) {
  select {
  case (*c).outputStream <- msg:
  case <-(*c).signalCloseLoopChan:
    err = errors.New("connection is closed")
  }
  return
}
// 关闭连接对象
func (c *Connection) Close() {
  _ = (*c).conn.Close()
  (*c).lock.Lock()
  if !(*c).isClosed {
    close((*c).signalCloseLoopChan)
  }
  (*c).lock.Unlock()
}
// 读取循环
func (c *Connection) readLoop() {
  // 不停的读取长连接中的消息,只要存在消息就将其放到队列中
  for {
    _, bytes, err := (*c).conn.ReadMessage()
    if err != nil {
      (*c).Close()
    }
    select {
    case <-(*c).signalCloseLoopChan:
      (*c).Close()
    case (*c).inputStream <- bytes:
    }
  }
}
// 写入循环
func (c *Connection) writeLoop() {
  // 只要队列中存在消息,就将其写入
  var data []byte
  for {
    select {
    case data = <-(*c).outputStream:
    case <-(*c).signalCloseLoopChan:
      (*c).Close()
    }
    err := (*c).conn.WriteMessage(websocket.TextMessage, data)
    if err != nil {
      _ = (*c).conn.Close()
    }
  }
}

至此,你已经学会了如何使用Go构建WebSocket服务。

到此这篇关于使用Go基于WebSocket构建千万级视频直播弹幕系统的代码详解的文章就介绍到这了,更多相关go WebSocket视频直播弹幕内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • 深入理解golang的基本类型排序与slice排序

    深入理解golang的基本类型排序与slice排序

    大家都知道排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。下面就来详细介绍golang的基本类型排序与slice排序,有需要的朋友们可以参考借鉴。
    2016-09-09
  • 基于Golang实现Redis协议解析器

    基于Golang实现Redis协议解析器

    这篇文章主要为大家详细介绍了如何通过GO语言编写简单的Redis协议解析器,文中的示例代码讲解详细,对我们深入了解Go语言有一定的帮助,需要的可以参考一下
    2023-03-03
  • Go 协程超时控制的实现

    Go 协程超时控制的实现

    本文主要介绍了Go 协程超时控制的实现,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-08-08
  • 使用Go语言进行安卓开发的详细教程

    使用Go语言进行安卓开发的详细教程

    本文将介绍如何使用Go语言进行安卓开发,我们将探讨使用Go语言进行安卓开发的优点、准备工作、基本概念和示例代码,通过本文的学习,你将了解如何使用Go语言构建高效的安卓应用程序,需要的朋友可以参考下
    2023-11-11
  • 特殊字符的json序列化总结大全

    特殊字符的json序列化总结大全

    这篇文章主要给大家介绍了关于特殊字符的json序列化的相关资料,通过示例代码分别给大家介绍了关于python 、 rust 、 java 和golang对特殊字符的json序列化操作,需要的朋友可以参考借鉴,下面来一起学习学习吧
    2018-09-09
  • golang开发微框架Gin的安装测试及简介

    golang开发微框架Gin的安装测试及简介

    这篇文章主要为大家介绍了golang微框架Gin的安装测试及简介,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加薪
    2021-11-11
  • Go语言模拟while语句实现无限循环的方法

    Go语言模拟while语句实现无限循环的方法

    这篇文章主要介绍了Go语言模拟while语句实现无限循环的方法,实例分析了for语句模拟while语句的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-02-02
  • VSCode必装Go语言以下插件的思路详解

    VSCode必装Go语言以下插件的思路详解

    这篇文章主要介绍了VSCode必装Go语言以下插件的思路详解,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-04-04
  • Golang unsafe.Sizeof函数代码示例使用解析

    Golang unsafe.Sizeof函数代码示例使用解析

    这篇文章主要为大家介绍了Golang unsafe.Sizeof函数代码示例使用解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-12-12
  • Golang实现自己的Redis(TCP篇)实例探究

    Golang实现自己的Redis(TCP篇)实例探究

    这篇文章主要介绍了Golang实现自己的Redis(TCP篇)实例探究,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2024-01-01

最新评论