0
评论
科普：QUIC协议原理分析
beyond 发表了文章 • 293 次浏览 • 2019-11-29 18:33
作者介绍：罗成，腾讯资深研发工程师。目前主要负责腾讯 stgw(腾讯安全云网关)的相关工作，整体推进腾讯内部及腾讯公有云，混合云的七层负载均衡及全站 HTTPS 接入。对 HTTPS，SPDY，HTTP2，QUIC 等应用层协议、高性能服务器技术、云网络技术、用户访问速度、分布式文件传输等有较深的理解。
本文主要介绍 QUIC 协议产生的背景和核心特性。
写在前面
如果你的 App，在不需要任何修改的情况下就能提升 15% 以上的访问速度。特别是弱网络的时候能够提升 20% 以上的访问速度。
如果你的 App，在频繁切换 4G 和 WIFI 网络的情况下，不会断线，不需要重连，用户无任何感知。如果你的 App，既需要 TLS 的安全，也想实现 HTTP2 多路复用的强大。
如果你刚刚才听说 HTTP2 是下一代互联网协议，如果你刚刚才关注到 TLS1.3 是一个革命性具有里程碑意义的协议，但是这两个协议却一直在被另一个更新兴的协议所影响和挑战。
如果这个新兴的协议，它的名字就叫做“快”，并且正在标准化为新一代的互联网传输协议。
你愿意花一点点时间了解这个协议吗?你愿意投入精力去研究这个协议吗?你愿意全力推动业务来使用这个协议吗?
QUIC 概述
Quic 全称 quick udp internet connection [1]，“快速 UDP 互联网连接”，(和英文 quick 谐音，简称“快”)是由 google 提出的使用 udp 进行多路并发传输的协议。
Quic 相比现在广泛应用的 http2+tcp+tls 协议有如下优势 [2]：
减少了 TCP 三次握手及 TLS 握手时间。
改进的拥塞控制。
避免队头阻塞的多路复用。
连接迁移。
前向冗余纠错。
为什么需要 QUIC
从上个世纪 90 年代互联网开始兴起一直到现在，大部分的互联网流量传输只使用了几个网络协议。使用 IPv4 进行路由，使用 TCP 进行连接层面的流量控制，使用 SSL/TLS 协议实现传输安全，使用 DNS 进行域名解析，使用 HTTP 进行应用数据的传输。
而且近三十年来，这几个协议的发展都非常缓慢。TCP 主要是拥塞控制算法的改进，SSL/TLS 基本上停留在原地，几个小版本的改动主要是密码套件的升级，TLS1.3[3] 是一个飞跃式的变化，但截止到今天，还没有正式发布。IPv4 虽然有一个大的进步，实现了 IPv6，DNS 也增加了一个安全的 DNSSEC，但和 IPv6 一样，部署进度较慢。
随着移动互联网快速发展以及物联网的逐步兴起，网络交互的场景越来越丰富，网络传输的内容也越来越庞大，用户对网络传输效率和 WEB 响应速度的要求也越来越高。
一方面是历史悠久使用广泛的古老协议，另外一方面用户的使用场景对传输性能的要求又越来越高。如下几个由来已久的问题和矛盾就变得越来越突出。
协议历史悠久导致中间设备僵化。
依赖于操作系统的实现导致协议本身僵化。
建立连接的握手延迟大。
队头阻塞。
这里分小节简单说明一下：
中间设备的僵化
可能是 TCP 协议使用得太久，也非常可靠。所以我们很多中间设备，包括防火墙、NAT 网关，整流器等出现了一些约定俗成的动作。
比如有些防火墙只允许通过 80 和 443，不放通其他端口。NAT 网关在转换网络地址时重写传输层的头部，有可能导致双方无法使用新的传输格式。整流器和中间代理有时候出于安全的需要，会删除一些它们不认识的选项字段。
TCP 协议本来是支持端口、选项及特性的增加和修改。但是由于 TCP 协议和知名端口及选项使用的历史太悠久，中间设备已经依赖于这些潜规则，所以对这些内容的修改很容易遭到中间环节的干扰而失败。
而这些干扰，也导致很多在 TCP 协议上的优化变得小心谨慎，步履维艰。
依赖于操作系统的实现导致协议僵化
TCP 是由操作系统在内核西方栈层面实现的，应用程序只能使用，不能直接修改。虽然应用程序的更新迭代非常快速和简单。但是 TCP 的迭代却非常缓慢，原因就是操作系统升级很麻烦。
现在移动终端更加流行，但是移动端部分用户的操作系统升级依然可能滞后数年时间。PC 端的系统升级滞后得更加严重，windows xp 现在还有大量用户在使用，尽管它已经存在快 20 年。
服务端系统不依赖用户升级，但是由于操作系统升级涉及到底层软件和运行库的更新，所以也比较保守和缓慢。
这也就意味着即使 TCP 有比较好的特性更新，也很难快速推广。比如 TCP Fast Open。它虽然 2013 年就被提出了，但是 Windows 很多系统版本依然不支持它。
建立连接的握手延迟大
不管是 HTTP1.0/1.1 还是 HTTPS，HTTP2，都使用了 TCP 进行传输。HTTPS 和 HTTP2 还需要使用 TLS 协议来进行安全传输。这就出现了两个握手延迟：
1.TCP 三次握手导致的 TCP 连接建立的延迟。
2.TLS 完全握手需要至少 2 个 RTT 才能建立，简化握手需要 1 个 RTT 的握手延迟。
对于很多短连接场景，这样的握手延迟影响很大，且无法消除。
队头阻塞
队头阻塞主要是 TCP 协议的可靠性机制引入的。TCP 使用序列号来标识数据的顺序，数据必须按照顺序处理，如果前面的数据丢失，后面的数据就算到达了也不会通知应用层来处理。
另外 TLS 协议层面也有一个队头阻塞，因为 TLS 协议都是按照 record 来处理数据的，如果一个 record 中丢失了数据，也会导致整个 record 无法正确处理。
概括来讲，TCP 和 TLS1.2 之前的协议存在着结构性的问题，如果继续在现有的 TCP、TLS 协议之上实现一个全新的应用层协议，依赖于操作系统、中间设备还有用户的支持。部署成本非常高，阻力非常大。
所以 QUIC 协议选择了 UDP，因为 UDP 本身没有连接的概念，不需要三次握手，优化了连接建立的握手延迟，同时在应用程序层面实现了 TCP 的可靠性，TLS 的安全性和 HTTP2 的并发性，只需要用户端和服务端的应用程序支持 QUIC 协议，完全避开了操作系统和中间设备的限制。
QUIC 核心特性连接建立延时低
0RTT 建连可以说是 QUIC 相比 HTTP2 最大的性能优势。那什么是 0RTT 建连呢?这里面有两层含义。
传输层 0RTT 就能建立连接。
加密层 0RTT 就能建立加密连接。
图 1 HTTPS 及 QUIC 建连过程
比如上图左边是 HTTPS 的一次完全握手的建连过程，需要 3 个 RTT。就算是 Session Resumption[14]，也需要至少 2 个 RTT。
而 QUIC 呢?由于建立在 UDP 的基础上，同时又实现了 0RTT 的安全握手，所以在大部分情况下，只需要 0 个 RTT 就能实现数据发送，在实现前向加密 [15] 的基础上，并且 0RTT 的成功率相比 TLS 的 Sesison Ticket[13] 要高很多。
改进的拥塞控制
TCP 的拥塞控制实际上包含了四个算法：慢启动，拥塞避免，快速重传，快速恢复 [22]。
QUIC 协议当前默认使用了 TCP 协议的 Cubic 拥塞控制算法 [6]，同时也支持 CubicBytes, Reno, RenoBytes, BBR, PCC 等拥塞控制算法。
从拥塞算法本身来看，QUIC 只是按照 TCP 协议重新实现了一遍，那么 QUIC 协议到底改进在哪些方面呢?主要有如下几点：
可插拔
什么叫可插拔呢?就是能够非常灵活地生效，变更和停止。体现在如下方面：
应用程序层面就能实现不同的拥塞控制算法，不需要操作系统，不需要内核支持。这是一个飞跃，因为传统的 TCP 拥塞控制，必须要端到端的网络协议栈支持，才能实现控制效果。而内核和操作系统的部署成本非常高，升级周期很长，这在产品快速迭代，网络爆炸式增长的今天，显然有点满足不了需求。
即使是单个应用程序的不同连接也能支持配置不同的拥塞控制。就算是一台服务器，接入的用户网络环境也千差万别，结合大数据及人工智能处理，我们能为各个用户提供不同的但又更加精准更加有效的拥塞控制。比如 BBR 适合，Cubic 适合。
应用程序不需要停机和升级就能实现拥塞控制的变更，我们在服务端只需要修改一下配置，reload 一下，完全不需要停止服务就能实现拥塞控制的切换。
STGW 在配置层面进行了优化，我们可以针对不同业务，不同网络制式，甚至不同的 RTT，使用不同的拥塞控制算法。
单调递增的 Packet Number
TCP 为了保证可靠性，使用了基于字节序号的 Sequence Number 及 Ack 来确认消息的有序到达。
QUIC 同样是一个可靠的协议，它使用 Packet Number 代替了 TCP 的 sequence number，并且每个 Packet Number 都严格递增，也就是说就算 Packet N 丢失了，重传的 Packet N 的 Packet Number 已经不是 N，而是一个比 N 大的值。而 TCP 呢，重传 segment 的 sequence number 和原始的 segment 的 Sequence Number 保持不变，也正是由于这个特性，引入了 Tcp 重传的歧义问题。
图 2 Tcp 重传歧义性
如上图所示，超时事件 RTO 发生后，客户端发起重传，然后接收到了 Ack 数据。由于序列号一样，这个 Ack 数据到底是原始请求的响应还是重传请求的响应呢?不好判断。
如果算成原始请求的响应，但实际上是重传请求的响应(上图左)，会导致采样 RTT 变大。如果算成重传请求的响应，但实际上是原始请求的响应，又很容易导致采样 RTT 过小。
由于 Quic 重传的 Packet 和原始 Packet 的 Pakcet Number 是严格递增的，所以很容易就解决了这个问题。
图 3 Quic 重传没有歧义性
如上图所示，RTO 发生后，根据重传的 Packet Number 就能确定精确的 RTT 计算。如果 Ack 的 Packet Number 是 N+M，就根据重传请求计算采样 RTT。如果 Ack 的 Pakcet Number 是 N，就根据原始请求的时间计算采样 RTT，没有歧义性。
但是单纯依靠严格递增的 Packet Number 肯定是无法保证数据的顺序性和可靠性。QUIC 又引入了一个 Stream Offset 的概念。
即一个 Stream 可以经过多个 Packet 传输，Packet Number 严格递增，没有依赖。但是 Packet 里的 Payload 如果是 Stream 的话，就需要依靠 Stream 的 Offset 来保证应用数据的顺序。如错误! 未找到引用源。所示，发送端先后发送了 Pakcet N 和 Pakcet N+1，Stream 的 Offset 分别是 x 和 x+y。
假设 Packet N 丢失了，发起重传，重传的 Packet Number 是 N+2，但是它的 Stream 的 Offset 依然是 x，这样就算 Packet N + 2 是后到的，依然可以将 Stream x 和 Stream x+y 按照顺序组织起来，交给应用程序处理。
图 4 Stream Offset 保证有序性
不允许 Reneging
什么叫 Reneging 呢?就是接收方丢弃已经接收并且上报给 SACK 选项的内容 [8]。TCP 协议不鼓励这种行为，但是协议层面允许这样的行为。主要是考虑到服务器资源有限，比如 Buffer 溢出，内存不够等情况。
Reneging 对数据重传会产生很大的干扰。因为 Sack 都已经表明接收到了，但是接收端事实上丢弃了该数据。
QUIC 在协议层面禁止 Reneging，一个 Packet 只要被 Ack，就认为它一定被正确接收，减少了这种干扰。
更多的 Ack 块
TCP 的 Sack 选项能够告诉发送方已经接收到的连续 Segment 的范围，方便发送方进行选择性重传。
由于 TCP 头部最大只有 60 个字节，标准头部占用了 20 字节，所以 Tcp Option 最大长度只有 40 字节，再加上 Tcp Timestamp option 占用了 10 个字节 [25]，所以留给 Sack 选项的只有 30 个字节。
每一个 Sack Block 的长度是 8 个，加上 Sack Option 头部 2 个字节，也就意味着 Tcp Sack Option 最大只能提供 3 个 Block。
但是 Quic Ack Frame 可以同时提供 256 个 Ack Block，在丢包率比较高的网络下，更多的 Sack Block 可以提升网络的恢复速度，减少重传量。
Ack Delay 时间
Tcp 的 Timestamp 选项存在一个问题 [25]，它只是回显了发送方的时间戳，但是没有计算接收端接收到 segment 到发送 Ack 该 segment 的时间。这个时间可以简称为 Ack Delay。
这样就会导致 RTT 计算误差。如下图：
可以认为 TCP 的 RTT 计算：
而 Quic 计算如下：
当然 RTT 的具体计算没有这么简单，需要采样，参考历史数值进行平滑计算，参考如下公式 [9]。
基于 stream 和 connecton 级别的流量控制
QUIC 的流量控制 [22] 类似 HTTP2，即在 Connection 和 Stream 级别提供了两种流量控制。为什么需要两类流量控制呢?主要是因为 QUIC 支持多路复用。
Stream 可以认为就是一条 HTTP 请求。
Connection 可以类比一条 TCP 连接。多路复用意味着在一条 Connetion 上会同时存在多条 Stream。既需要对单个 Stream 进行控制，又需要针对所有 Stream 进行总体控制。
QUIC 实现流量控制的原理比较简单：
通过 window_update 帧告诉对端自己可以接收的字节数，这样发送方就不会发送超过这个数量的数据。
通过 BlockFrame 告诉对端由于流量控制被阻塞了，无法发送数据。
QUIC 的流量控制和 TCP 有点区别，TCP 为了保证可靠性，窗口左边沿向右滑动时的长度取决于已经确认的字节数。如果中间出现丢包，就算接收到了更大序号的 Segment，窗口也无法超过这个序列号。
但 QUIC 不同，就算此前有些 packet 没有接收到，它的滑动只取决于接收到的最大偏移字节数。
图 5 Quic Flow Control针对 Stream：
针对 Connection：
同样地，STGW 也在连接和 Stream 级别设置了不同的窗口数。
最重要的是，我们可以在内存不足或者上游处理性能出现问题时，通过流量控制来限制传输速率，保障服务可用性。
没有队头阻塞的多路复用
QUIC 的多路复用和 HTTP2 类似。在一条 QUIC 连接上可以并发发送多个 HTTP 请求 (stream)。但是 QUIC 的多路复用相比 HTTP2 有一个很大的优势。
QUIC 一个连接上的多个 stream 之间没有依赖。这样假如 stream2 丢了一个 udp packet，也只会影响 stream2 的处理。不会影响 stream2 之前及之后的 stream 的处理。
这也就在很大程度上缓解甚至消除了队头阻塞的影响。
多路复用是 HTTP2 最强大的特性 [7]，能够将多条请求在一条 TCP 连接上同时发出去。但也恶化了 TCP 的一个问题，队头阻塞 [11]，如下图示：
图 6 HTTP2 队头阻塞
HTTP2 在一个 TCP 连接上同时发送 4 个 Stream。其中 Stream1 已经正确到达，并被应用层读取。但是 Stream2 的第三个 tcp segment 丢失了，TCP 为了保证数据的可靠性，需要发送端重传第 3 个 segment 才能通知应用层读取接下去的数据，虽然这个时候 Stream3 和 Stream4 的全部数据已经到达了接收端，但都被阻塞住了。
不仅如此，由于 HTTP2 强制使用 TLS，还存在一个 TLS 协议层面的队头阻塞 [12]。
图 7 TLS 队头阻塞
Record 是 TLS 协议处理的最小单位，最大不能超过 16K，一些服务器比如 Nginx 默认的大小就是 16K。由于一个 record 必须经过数据一致性校验才能进行加解密，所以一个 16K 的 record，就算丢了一个字节，也会导致已经接收到的 15.99K 数据无法处理，因为它不完整。
那 QUIC 多路复用为什么能避免上述问题呢?
QUIC 最基本的传输单元是 Packet，不会超过 MTU 的大小，整个加密和认证过程都是基于 Packet 的，不会跨越多个 Packet。这样就能避免 TLS 协议存在的队头阻塞。
Stream 之间相互独立，比如 Stream2 丢了一个 Pakcet，不会影响 Stream3 和 Stream4。不存在 TCP 队头阻塞。
图 8 QUIC 多路复用时没有队头阻塞的问题
当然，并不是所有的 QUIC 数据都不会受到队头阻塞的影响，比如 QUIC 当前也是使用 Hpack 压缩算法 [10]，由于算法的限制，丢失一个头部数据时，可能遇到队头阻塞。
总体来说，QUIC 在传输大量数据时，比如视频，受到队头阻塞的影响很小。
加密认证的报文
TCP 协议头部没有经过任何加密和认证，所以在传输过程中很容易被中间网络设备篡改，注入和窃听。比如修改序列号、滑动窗口。这些行为有可能是出于性能优化，也有可能是主动攻击。
但是 QUIC 的 packet 可以说是武装到了牙齿。除了个别报文比如 PUBLIC_RESET 和 CHLO，所有报文头部都是经过认证的，报文 Body 都是经过加密的。
这样只要对 QUIC 报文任何修改，接收端都能够及时发现，有效地降低了安全风险。
如下图所示，红色部分是 Stream Frame 的报文头部，有认证。绿色部分是报文内容，全部经过加密。
连接迁移
一条 TCP 连接 [17] 是由四元组标识的(源 IP，源端口，目的 IP，目的端口)。什么叫连接迁移呢?就是当其中任何一个元素发生变化时，这条连接依然维持着，能够保持业务逻辑不中断。当然这里面主要关注的是客户端的变化，因为客户端不可控并且网络环境经常发生变化，而服务端的 IP 和端口一般都是固定的。
比如大家使用手机在 WIFI 和 4G 移动网络切换时，客户端的 IP 肯定会发生变化，需要重新建立和服务端的 TCP 连接。
又比如大家使用公共 NAT 出口时，有些连接竞争时需要重新绑定端口，导致客户端的端口发生变化，同样需要重新建立 TCP 连接。
针对 TCP 的连接变化，MPTCP[5] 其实已经有了解决方案，但是由于 MPTCP 需要操作系统及网络协议栈支持，部署阻力非常大，目前并不适用。
所以从 TCP 连接的角度来讲，这个问题是无解的。
那 QUIC 是如何做到连接迁移呢?很简单，任何一条 QUIC 连接不再以 IP 及端口四元组标识，而是以一个 64 位的随机数作为 ID 来标识，这样就算 IP 或者端口发生变化时，只要 ID 不变，这条连接依然维持着，上层业务逻辑感知不到变化，不会中断，也就不需要重连。
由于这个 ID 是客户端随机产生的，并且长度有 64 位，所以冲突概率非常低。
其他亮点
此外，QUIC 还能实现前向冗余纠错，在重要的包比如握手消息发生丢失时，能够根据冗余信息还原出握手消息。
QUIC 还能实现证书压缩，减少证书传输量，针对包头进行验证等。
限于篇幅，本文不再详细介绍，有兴趣的可以参考文档 [23] 和文档 [4] 和文档 [26]。
参考线索
[1]. https://www.chromium.org/quic
[2]. https://docs.google.com/docume ... /edit
[3]. E. Rescorla, “The Transport Layer Security (TLS) Protocol Version 1.3”, draft-ietf-tls-tls13-21, https://tools.ietf.org/html/dr ... 13-21, July 03, 2017
[4]. Adam Langley,Wan-Teh Chang, “QUIC Crypto”，https://docs.google.com/docume ... /edit, 20161206
[5]. https://www.multipath-tcp.org/
[6]. Ha, S., Rhee, I., and L. Xu, "CUBIC: A New TCP-Friendly High-Speed TCP Variant", ACM SIGOPS Operating System Review , 2008.
[7]. M. Belshe,BitGo, R. Peon, “Hypertext Transfer Protocol Version 2 (HTTP/2)”, RFC 7540, May 2015
[8]. M. Mathis,J. Mahdavi,S. Floyd,A. Romanow,“TCP Selective Acknowledgment Options”, rfc2018, https://tools.ietf.org/html/rfc2018, October 1996
[9]. V. Paxson，M. Allman，J. Chu，M. Sargent，“Computing TCP's Retransmission Timer”， rfc6298, https://tools.ietf.org/html/rfc6298, June 2011
[10]. R. Peon,H. Ruellan,“HPACK: Header Compression for HTTP/2”,RFC7541,May 2015
[11]. M. Scharf, Alcatel-Lucent Bell Labs, S. Kiesel, “Quantifying Head-of-Line Blocking in TCP and SCTP”, https://tools.ietf.org/id/draf ... .html, July 15, 2013
[12]. Ilya Grigorik，“Optimizing TLS Record Size & Buffering Latency”, https://www.igvita.com/2013/10 ... ency/, October 24, 2013
[13]. J. Salowey,H. Zhou,P. Eronen,H. Tschofenig, “Transport Layer Security (TLS) Session Resumption without Server-Side State”, RFC5077, January 2008
[14]. Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, DOI 10.17487/RFC5246, August 2008, .
[15]. Shirey, R., "Internet Security Glossary, Version 2", FYI , RFC 4949, August 2007
[16]. 罗成，“HTTPS性能优化”， http://www.infoq.com/cn/presen ... https，February.2017
[17]. Postel, J., "Transmission Control Protocol", STD 7, RFC793, September 1981.
[18]. J. Postel,“User Datagram Protocol”, RFC768,August 1980
[19]. Q. Dang, S. Santesson,K. Moriarty,D. Brown.T. Polk, “Internet X.509 Public Key Infrastructure: Additional Algorithms and Identifiers for DSA and ECDSA”,RFC5758, January 2010
[20]. Bassham, L., Polk, W., and R. Housley, "Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 3279, April 2002
[21]. D.Cooper,S.Santesson, S.Farrell,S. Boeyen,R. Housley,W.Polk, “Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile”, RFC5280, May 2008
[22]. M. Allman,V. Paxson,E. Blanton, "TCP Congestion Control”,RFC5681, September 2009
[23]. Robbie Shade, “Flow control in QUIC”, https://docs.google.com/docume ... it%23, May, 2016,
[24]. ianswett , “QUIC fec v1”, https://docs.google.com/docume ... tytjt, 2016-02-19
[25]. D.Borman,B.Braden,V.Jacobson,R.Scheffenegger, Ed. “TCP Extensions for High Performance”,rfc7323, https://tools.ietf.org/html/rfc7323,September 2014
[26]. 罗成，“WEB加速，协议先行”， https://zhuanlan.zhihu.com/p/27938635，july, 2017 查看全部
本文主要介绍 QUIC 协议产生的背景和核心特性。
写在前面
如果你的 App，在不需要任何修改的情况下就能提升 15% 以上的访问速度。特别是弱网络的时候能够提升 20% 以上的访问速度。
如果你的 App，在频繁切换 4G 和 WIFI 网络的情况下，不会断线，不需要重连，用户无任何感知。如果你的 App，既需要 TLS 的安全，也想实现 HTTP2 多路复用的强大。
如果你刚刚才听说 HTTP2 是下一代互联网协议，如果你刚刚才关注到 TLS1.3 是一个革命性具有里程碑意义的协议，但是这两个协议却一直在被另一个更新兴的协议所影响和挑战。
如果这个新兴的协议，它的名字就叫做“快”，并且正在标准化为新一代的互联网传输协议。
你愿意花一点点时间了解这个协议吗?你愿意投入精力去研究这个协议吗?你愿意全力推动业务来使用这个协议吗?
QUIC 概述
Quic 全称 quick udp internet connection [1]，“快速 UDP 互联网连接”，(和英文 quick 谐音，简称“快”)是由 google 提出的使用 udp 进行多路并发传输的协议。
Quic 相比现在广泛应用的 http2+tcp+tls 协议有如下优势 [2]：
减少了 TCP 三次握手及 TLS 握手时间。
改进的拥塞控制。
避免队头阻塞的多路复用。
连接迁移。
前向冗余纠错。
为什么需要 QUIC
从上个世纪 90 年代互联网开始兴起一直到现在，大部分的互联网流量传输只使用了几个网络协议。使用 IPv4 进行路由，使用 TCP 进行连接层面的流量控制，使用 SSL/TLS 协议实现传输安全，使用 DNS 进行域名解析，使用 HTTP 进行应用数据的传输。
而且近三十年来，这几个协议的发展都非常缓慢。TCP 主要是拥塞控制算法的改进，SSL/TLS 基本上停留在原地，几个小版本的改动主要是密码套件的升级，TLS1.3[3] 是一个飞跃式的变化，但截止到今天，还没有正式发布。IPv4 虽然有一个大的进步，实现了 IPv6，DNS 也增加了一个安全的 DNSSEC，但和 IPv6 一样，部署进度较慢。
随着移动互联网快速发展以及物联网的逐步兴起，网络交互的场景越来越丰富，网络传输的内容也越来越庞大，用户对网络传输效率和 WEB 响应速度的要求也越来越高。
一方面是历史悠久使用广泛的古老协议，另外一方面用户的使用场景对传输性能的要求又越来越高。如下几个由来已久的问题和矛盾就变得越来越突出。
协议历史悠久导致中间设备僵化。
依赖于操作系统的实现导致协议本身僵化。
建立连接的握手延迟大。
队头阻塞。
这里分小节简单说明一下：
中间设备的僵化
可能是 TCP 协议使用得太久，也非常可靠。所以我们很多中间设备，包括防火墙、NAT 网关，整流器等出现了一些约定俗成的动作。
比如有些防火墙只允许通过 80 和 443，不放通其他端口。NAT 网关在转换网络地址时重写传输层的头部，有可能导致双方无法使用新的传输格式。整流器和中间代理有时候出于安全的需要，会删除一些它们不认识的选项字段。
TCP 协议本来是支持端口、选项及特性的增加和修改。但是由于 TCP 协议和知名端口及选项使用的历史太悠久，中间设备已经依赖于这些潜规则，所以对这些内容的修改很容易遭到中间环节的干扰而失败。
而这些干扰，也导致很多在 TCP 协议上的优化变得小心谨慎，步履维艰。
依赖于操作系统的实现导致协议僵化
TCP 是由操作系统在内核西方栈层面实现的，应用程序只能使用，不能直接修改。虽然应用程序的更新迭代非常快速和简单。但是 TCP 的迭代却非常缓慢，原因就是操作系统升级很麻烦。
现在移动终端更加流行，但是移动端部分用户的操作系统升级依然可能滞后数年时间。PC 端的系统升级滞后得更加严重，windows xp 现在还有大量用户在使用，尽管它已经存在快 20 年。
服务端系统不依赖用户升级，但是由于操作系统升级涉及到底层软件和运行库的更新，所以也比较保守和缓慢。
这也就意味着即使 TCP 有比较好的特性更新，也很难快速推广。比如 TCP Fast Open。它虽然 2013 年就被提出了，但是 Windows 很多系统版本依然不支持它。
建立连接的握手延迟大
不管是 HTTP1.0/1.1 还是 HTTPS，HTTP2，都使用了 TCP 进行传输。HTTPS 和 HTTP2 还需要使用 TLS 协议来进行安全传输。这就出现了两个握手延迟：
1.TCP 三次握手导致的 TCP 连接建立的延迟。
2.TLS 完全握手需要至少 2 个 RTT 才能建立，简化握手需要 1 个 RTT 的握手延迟。
对于很多短连接场景，这样的握手延迟影响很大，且无法消除。
队头阻塞
队头阻塞主要是 TCP 协议的可靠性机制引入的。TCP 使用序列号来标识数据的顺序，数据必须按照顺序处理，如果前面的数据丢失，后面的数据就算到达了也不会通知应用层来处理。
另外 TLS 协议层面也有一个队头阻塞，因为 TLS 协议都是按照 record 来处理数据的，如果一个 record 中丢失了数据，也会导致整个 record 无法正确处理。
概括来讲，TCP 和 TLS1.2 之前的协议存在着结构性的问题，如果继续在现有的 TCP、TLS 协议之上实现一个全新的应用层协议，依赖于操作系统、中间设备还有用户的支持。部署成本非常高，阻力非常大。
所以 QUIC 协议选择了 UDP，因为 UDP 本身没有连接的概念，不需要三次握手，优化了连接建立的握手延迟，同时在应用程序层面实现了 TCP 的可靠性，TLS 的安全性和 HTTP2 的并发性，只需要用户端和服务端的应用程序支持 QUIC 协议，完全避开了操作系统和中间设备的限制。
QUIC 核心特性连接建立延时低
0RTT 建连可以说是 QUIC 相比 HTTP2 最大的性能优势。那什么是 0RTT 建连呢?这里面有两层含义。
传输层 0RTT 就能建立连接。
加密层 0RTT 就能建立加密连接。
图 1 HTTPS 及 QUIC 建连过程
比如上图左边是 HTTPS 的一次完全握手的建连过程，需要 3 个 RTT。就算是 Session Resumption[14]，也需要至少 2 个 RTT。
而 QUIC 呢?由于建立在 UDP 的基础上，同时又实现了 0RTT 的安全握手，所以在大部分情况下，只需要 0 个 RTT 就能实现数据发送，在实现前向加密 [15] 的基础上，并且 0RTT 的成功率相比 TLS 的 Sesison Ticket[13] 要高很多。
改进的拥塞控制
TCP 的拥塞控制实际上包含了四个算法：慢启动，拥塞避免，快速重传，快速恢复 [22]。
QUIC 协议当前默认使用了 TCP 协议的 Cubic 拥塞控制算法 [6]，同时也支持 CubicBytes, Reno, RenoBytes, BBR, PCC 等拥塞控制算法。
从拥塞算法本身来看，QUIC 只是按照 TCP 协议重新实现了一遍，那么 QUIC 协议到底改进在哪些方面呢?主要有如下几点：
可插拔
什么叫可插拔呢?就是能够非常灵活地生效，变更和停止。体现在如下方面：
应用程序层面就能实现不同的拥塞控制算法，不需要操作系统，不需要内核支持。这是一个飞跃，因为传统的 TCP 拥塞控制，必须要端到端的网络协议栈支持，才能实现控制效果。而内核和操作系统的部署成本非常高，升级周期很长，这在产品快速迭代，网络爆炸式增长的今天，显然有点满足不了需求。
即使是单个应用程序的不同连接也能支持配置不同的拥塞控制。就算是一台服务器，接入的用户网络环境也千差万别，结合大数据及人工智能处理，我们能为各个用户提供不同的但又更加精准更加有效的拥塞控制。比如 BBR 适合，Cubic 适合。
应用程序不需要停机和升级就能实现拥塞控制的变更，我们在服务端只需要修改一下配置，reload 一下，完全不需要停止服务就能实现拥塞控制的切换。
STGW 在配置层面进行了优化，我们可以针对不同业务，不同网络制式，甚至不同的 RTT，使用不同的拥塞控制算法。
单调递增的 Packet Number
TCP 为了保证可靠性，使用了基于字节序号的 Sequence Number 及 Ack 来确认消息的有序到达。
QUIC 同样是一个可靠的协议，它使用 Packet Number 代替了 TCP 的 sequence number，并且每个 Packet Number 都严格递增，也就是说就算 Packet N 丢失了，重传的 Packet N 的 Packet Number 已经不是 N，而是一个比 N 大的值。而 TCP 呢，重传 segment 的 sequence number 和原始的 segment 的 Sequence Number 保持不变，也正是由于这个特性，引入了 Tcp 重传的歧义问题。
图 2 Tcp 重传歧义性
如上图所示，超时事件 RTO 发生后，客户端发起重传，然后接收到了 Ack 数据。由于序列号一样，这个 Ack 数据到底是原始请求的响应还是重传请求的响应呢?不好判断。
如果算成原始请求的响应，但实际上是重传请求的响应(上图左)，会导致采样 RTT 变大。如果算成重传请求的响应，但实际上是原始请求的响应，又很容易导致采样 RTT 过小。
由于 Quic 重传的 Packet 和原始 Packet 的 Pakcet Number 是严格递增的，所以很容易就解决了这个问题。
图 3 Quic 重传没有歧义性
如上图所示，RTO 发生后，根据重传的 Packet Number 就能确定精确的 RTT 计算。如果 Ack 的 Packet Number 是 N+M，就根据重传请求计算采样 RTT。如果 Ack 的 Pakcet Number 是 N，就根据原始请求的时间计算采样 RTT，没有歧义性。
但是单纯依靠严格递增的 Packet Number 肯定是无法保证数据的顺序性和可靠性。QUIC 又引入了一个 Stream Offset 的概念。
即一个 Stream 可以经过多个 Packet 传输，Packet Number 严格递增，没有依赖。但是 Packet 里的 Payload 如果是 Stream 的话，就需要依靠 Stream 的 Offset 来保证应用数据的顺序。如错误! 未找到引用源。所示，发送端先后发送了 Pakcet N 和 Pakcet N+1，Stream 的 Offset 分别是 x 和 x+y。
假设 Packet N 丢失了，发起重传，重传的 Packet Number 是 N+2，但是它的 Stream 的 Offset 依然是 x，这样就算 Packet N + 2 是后到的，依然可以将 Stream x 和 Stream x+y 按照顺序组织起来，交给应用程序处理。
图 4 Stream Offset 保证有序性
不允许 Reneging
什么叫 Reneging 呢?就是接收方丢弃已经接收并且上报给 SACK 选项的内容 [8]。TCP 协议不鼓励这种行为，但是协议层面允许这样的行为。主要是考虑到服务器资源有限，比如 Buffer 溢出，内存不够等情况。
Reneging 对数据重传会产生很大的干扰。因为 Sack 都已经表明接收到了，但是接收端事实上丢弃了该数据。
QUIC 在协议层面禁止 Reneging，一个 Packet 只要被 Ack，就认为它一定被正确接收，减少了这种干扰。
更多的 Ack 块
TCP 的 Sack 选项能够告诉发送方已经接收到的连续 Segment 的范围，方便发送方进行选择性重传。
由于 TCP 头部最大只有 60 个字节，标准头部占用了 20 字节，所以 Tcp Option 最大长度只有 40 字节，再加上 Tcp Timestamp option 占用了 10 个字节 [25]，所以留给 Sack 选项的只有 30 个字节。
每一个 Sack Block 的长度是 8 个，加上 Sack Option 头部 2 个字节，也就意味着 Tcp Sack Option 最大只能提供 3 个 Block。
但是 Quic Ack Frame 可以同时提供 256 个 Ack Block，在丢包率比较高的网络下，更多的 Sack Block 可以提升网络的恢复速度，减少重传量。
Ack Delay 时间
Tcp 的 Timestamp 选项存在一个问题 [25]，它只是回显了发送方的时间戳，但是没有计算接收端接收到 segment 到发送 Ack 该 segment 的时间。这个时间可以简称为 Ack Delay。
这样就会导致 RTT 计算误差。如下图：
可以认为 TCP 的 RTT 计算：
而 Quic 计算如下：
当然 RTT 的具体计算没有这么简单，需要采样，参考历史数值进行平滑计算，参考如下公式 [9]。
基于 stream 和 connecton 级别的流量控制
QUIC 的流量控制 [22] 类似 HTTP2，即在 Connection 和 Stream 级别提供了两种流量控制。为什么需要两类流量控制呢?主要是因为 QUIC 支持多路复用。
Stream 可以认为就是一条 HTTP 请求。
Connection 可以类比一条 TCP 连接。多路复用意味着在一条 Connetion 上会同时存在多条 Stream。既需要对单个 Stream 进行控制，又需要针对所有 Stream 进行总体控制。
QUIC 实现流量控制的原理比较简单：
通过 window_update 帧告诉对端自己可以接收的字节数，这样发送方就不会发送超过这个数量的数据。
通过 BlockFrame 告诉对端由于流量控制被阻塞了，无法发送数据。
QUIC 的流量控制和 TCP 有点区别，TCP 为了保证可靠性，窗口左边沿向右滑动时的长度取决于已经确认的字节数。如果中间出现丢包，就算接收到了更大序号的 Segment，窗口也无法超过这个序列号。
但 QUIC 不同，就算此前有些 packet 没有接收到，它的滑动只取决于接收到的最大偏移字节数。
图 5 Quic Flow Control针对 Stream：
针对 Connection：
同样地，STGW 也在连接和 Stream 级别设置了不同的窗口数。
最重要的是，我们可以在内存不足或者上游处理性能出现问题时，通过流量控制来限制传输速率，保障服务可用性。
没有队头阻塞的多路复用
QUIC 的多路复用和 HTTP2 类似。在一条 QUIC 连接上可以并发发送多个 HTTP 请求 (stream)。但是 QUIC 的多路复用相比 HTTP2 有一个很大的优势。
QUIC 一个连接上的多个 stream 之间没有依赖。这样假如 stream2 丢了一个 udp packet，也只会影响 stream2 的处理。不会影响 stream2 之前及之后的 stream 的处理。
这也就在很大程度上缓解甚至消除了队头阻塞的影响。
多路复用是 HTTP2 最强大的特性 [7]，能够将多条请求在一条 TCP 连接上同时发出去。但也恶化了 TCP 的一个问题，队头阻塞 [11]，如下图示：
图 6 HTTP2 队头阻塞
HTTP2 在一个 TCP 连接上同时发送 4 个 Stream。其中 Stream1 已经正确到达，并被应用层读取。但是 Stream2 的第三个 tcp segment 丢失了，TCP 为了保证数据的可靠性，需要发送端重传第 3 个 segment 才能通知应用层读取接下去的数据，虽然这个时候 Stream3 和 Stream4 的全部数据已经到达了接收端，但都被阻塞住了。
不仅如此，由于 HTTP2 强制使用 TLS，还存在一个 TLS 协议层面的队头阻塞 [12]。
图 7 TLS 队头阻塞
Record 是 TLS 协议处理的最小单位，最大不能超过 16K，一些服务器比如 Nginx 默认的大小就是 16K。由于一个 record 必须经过数据一致性校验才能进行加解密，所以一个 16K 的 record，就算丢了一个字节，也会导致已经接收到的 15.99K 数据无法处理，因为它不完整。
那 QUIC 多路复用为什么能避免上述问题呢?
QUIC 最基本的传输单元是 Packet，不会超过 MTU 的大小，整个加密和认证过程都是基于 Packet 的，不会跨越多个 Packet。这样就能避免 TLS 协议存在的队头阻塞。
Stream 之间相互独立，比如 Stream2 丢了一个 Pakcet，不会影响 Stream3 和 Stream4。不存在 TCP 队头阻塞。
图 8 QUIC 多路复用时没有队头阻塞的问题
当然，并不是所有的 QUIC 数据都不会受到队头阻塞的影响，比如 QUIC 当前也是使用 Hpack 压缩算法 [10]，由于算法的限制，丢失一个头部数据时，可能遇到队头阻塞。
总体来说，QUIC 在传输大量数据时，比如视频，受到队头阻塞的影响很小。
加密认证的报文
TCP 协议头部没有经过任何加密和认证，所以在传输过程中很容易被中间网络设备篡改，注入和窃听。比如修改序列号、滑动窗口。这些行为有可能是出于性能优化，也有可能是主动攻击。
但是 QUIC 的 packet 可以说是武装到了牙齿。除了个别报文比如 PUBLIC_RESET 和 CHLO，所有报文头部都是经过认证的，报文 Body 都是经过加密的。
这样只要对 QUIC 报文任何修改，接收端都能够及时发现，有效地降低了安全风险。
如下图所示，红色部分是 Stream Frame 的报文头部，有认证。绿色部分是报文内容，全部经过加密。
连接迁移
一条 TCP 连接 [17] 是由四元组标识的(源 IP，源端口，目的 IP，目的端口)。什么叫连接迁移呢?就是当其中任何一个元素发生变化时，这条连接依然维持着，能够保持业务逻辑不中断。当然这里面主要关注的是客户端的变化，因为客户端不可控并且网络环境经常发生变化，而服务端的 IP 和端口一般都是固定的。
比如大家使用手机在 WIFI 和 4G 移动网络切换时，客户端的 IP 肯定会发生变化，需要重新建立和服务端的 TCP 连接。
又比如大家使用公共 NAT 出口时，有些连接竞争时需要重新绑定端口，导致客户端的端口发生变化，同样需要重新建立 TCP 连接。
针对 TCP 的连接变化，MPTCP[5] 其实已经有了解决方案，但是由于 MPTCP 需要操作系统及网络协议栈支持，部署阻力非常大，目前并不适用。
所以从 TCP 连接的角度来讲，这个问题是无解的。
那 QUIC 是如何做到连接迁移呢?很简单，任何一条 QUIC 连接不再以 IP 及端口四元组标识，而是以一个 64 位的随机数作为 ID 来标识，这样就算 IP 或者端口发生变化时，只要 ID 不变，这条连接依然维持着，上层业务逻辑感知不到变化，不会中断，也就不需要重连。
由于这个 ID 是客户端随机产生的，并且长度有 64 位，所以冲突概率非常低。
其他亮点
此外，QUIC 还能实现前向冗余纠错，在重要的包比如握手消息发生丢失时，能够根据冗余信息还原出握手消息。
QUIC 还能实现证书压缩，减少证书传输量，针对包头进行验证等。
限于篇幅，本文不再详细介绍，有兴趣的可以参考文档 [23] 和文档 [4] 和文档 [26]。
参考线索
[1]. https://www.chromium.org/quic
[2]. https://docs.google.com/docume ... /edit
[3]. E. Rescorla, “The Transport Layer Security (TLS) Protocol Version 1.3”, draft-ietf-tls-tls13-21, https://tools.ietf.org/html/dr ... 13-21, July 03, 2017
[4]. Adam Langley,Wan-Teh Chang, “QUIC Crypto”，https://docs.google.com/docume ... /edit, 20161206
[5]. https://www.multipath-tcp.org/
[6]. Ha, S., Rhee, I., and L. Xu, "CUBIC: A New TCP-Friendly High-Speed TCP Variant", ACM SIGOPS Operating System Review , 2008.
[7]. M. Belshe,BitGo, R. Peon, “Hypertext Transfer Protocol Version 2 (HTTP/2)”, RFC 7540, May 2015
[8]. M. Mathis,J. Mahdavi,S. Floyd,A. Romanow,“TCP Selective Acknowledgment Options”, rfc2018, https://tools.ietf.org/html/rfc2018, October 1996
[9]. V. Paxson，M. Allman，J. Chu，M. Sargent，“Computing TCP's Retransmission Timer”， rfc6298, https://tools.ietf.org/html/rfc6298, June 2011
[10]. R. Peon,H. Ruellan,“HPACK: Header Compression for HTTP/2”,RFC7541,May 2015
[11]. M. Scharf, Alcatel-Lucent Bell Labs, S. Kiesel, “Quantifying Head-of-Line Blocking in TCP and SCTP”, https://tools.ietf.org/id/draf ... .html, July 15, 2013
[12]. Ilya Grigorik，“Optimizing TLS Record Size & Buffering Latency”, https://www.igvita.com/2013/10 ... ency/, October 24, 2013
[13]. J. Salowey,H. Zhou,P. Eronen,H. Tschofenig, “Transport Layer Security (TLS) Session Resumption without Server-Side State”, RFC5077, January 2008
[14]. Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, DOI 10.17487/RFC5246, August 2008, .
[15]. Shirey, R., "Internet Security Glossary, Version 2", FYI , RFC 4949, August 2007
[16]. 罗成，“HTTPS性能优化”， http://www.infoq.com/cn/presen ... https，February.2017
[17]. Postel, J., "Transmission Control Protocol", STD 7, RFC793, September 1981.
[18]. J. Postel,“User Datagram Protocol”, RFC768,August 1980
[19]. Q. Dang, S. Santesson,K. Moriarty,D. Brown.T. Polk, “Internet X.509 Public Key Infrastructure: Additional Algorithms and Identifiers for DSA and ECDSA”,RFC5758, January 2010
[20]. Bassham, L., Polk, W., and R. Housley, "Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 3279, April 2002
[21]. D.Cooper,S.Santesson, S.Farrell,S. Boeyen,R. Housley,W.Polk, “Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile”, RFC5280, May 2008
[22]. M. Allman,V. Paxson,E. Blanton, "TCP Congestion Control”,RFC5681, September 2009
[23]. Robbie Shade, “Flow control in QUIC”, https://docs.google.com/docume ... it%23, May, 2016,
[24]. ianswett , “QUIC fec v1”, https://docs.google.com/docume ... tytjt, 2016-02-19
[25]. D.Borman,B.Braden,V.Jacobson,R.Scheffenegger, Ed. “TCP Extensions for High Performance”,rfc7323, https://tools.ietf.org/html/rfc7323,September 2014
[26]. 罗成，“WEB加速，协议先行”， https://zhuanlan.zhihu.com/p/27938635，july, 2017 查看全部
作者介绍：罗成，腾讯资深研发工程师。目前主要负责腾讯 stgw(腾讯安全云网关)的相关工作，整体推进腾讯内部及腾讯公有云，混合云的七层负载均衡及全站 HTTPS 接入。对 HTTPS，SPDY，HTTP2，QUIC 等应用层协议、高性能服务器技术、云网络技术、用户访问速度、分布式文件传输等有较深的理解。
本文主要介绍 QUIC 协议产生的背景和核心特性。
写在前面
如果你的 App，在不需要任何修改的情况下就能提升 15% 以上的访问速度。特别是弱网络的时候能够提升 20% 以上的访问速度。
如果你的 App，在频繁切换 4G 和 WIFI 网络的情况下，不会断线，不需要重连，用户无任何感知。如果你的 App，既需要 TLS 的安全，也想实现 HTTP2 多路复用的强大。
如果你刚刚才听说 HTTP2 是下一代互联网协议，如果你刚刚才关注到 TLS1.3 是一个革命性具有里程碑意义的协议，但是这两个协议却一直在被另一个更新兴的协议所影响和挑战。
如果这个新兴的协议，它的名字就叫做“快”，并且正在标准化为新一代的互联网传输协议。
你愿意花一点点时间了解这个协议吗?你愿意投入精力去研究这个协议吗?你愿意全力推动业务来使用这个协议吗?
QUIC 概述
Quic 全称 quick udp internet connection [1]，“快速 UDP 互联网连接”，(和英文 quick 谐音，简称“快”)是由 google 提出的使用 udp 进行多路并发传输的协议。
Quic 相比现在广泛应用的 http2+tcp+tls 协议有如下优势 [2]：
减少了 TCP 三次握手及 TLS 握手时间。
改进的拥塞控制。
避免队头阻塞的多路复用。
连接迁移。
前向冗余纠错。
为什么需要 QUIC
从上个世纪 90 年代互联网开始兴起一直到现在，大部分的互联网流量传输只使用了几个网络协议。使用 IPv4 进行路由，使用 TCP 进行连接层面的流量控制，使用 SSL/TLS 协议实现传输安全，使用 DNS 进行域名解析，使用 HTTP 进行应用数据的传输。
而且近三十年来，这几个协议的发展都非常缓慢。TCP 主要是拥塞控制算法的改进，SSL/TLS 基本上停留在原地，几个小版本的改动主要是密码套件的升级，TLS1.3[3] 是一个飞跃式的变化，但截止到今天，还没有正式发布。IPv4 虽然有一个大的进步，实现了 IPv6，DNS 也增加了一个安全的 DNSSEC，但和 IPv6 一样，部署进度较慢。
随着移动互联网快速发展以及物联网的逐步兴起，网络交互的场景越来越丰富，网络传输的内容也越来越庞大，用户对网络传输效率和 WEB 响应速度的要求也越来越高。
一方面是历史悠久使用广泛的古老协议，另外一方面用户的使用场景对传输性能的要求又越来越高。如下几个由来已久的问题和矛盾就变得越来越突出。
协议历史悠久导致中间设备僵化。
依赖于操作系统的实现导致协议本身僵化。
建立连接的握手延迟大。
队头阻塞。
这里分小节简单说明一下：
中间设备的僵化
可能是 TCP 协议使用得太久，也非常可靠。所以我们很多中间设备，包括防火墙、NAT 网关，整流器等出现了一些约定俗成的动作。
比如有些防火墙只允许通过 80 和 443，不放通其他端口。NAT 网关在转换网络地址时重写传输层的头部，有可能导致双方无法使用新的传输格式。整流器和中间代理有时候出于安全的需要，会删除一些它们不认识的选项字段。
TCP 协议本来是支持端口、选项及特性的增加和修改。但是由于 TCP 协议和知名端口及选项使用的历史太悠久，中间设备已经依赖于这些潜规则，所以对这些内容的修改很容易遭到中间环节的干扰而失败。
而这些干扰，也导致很多在 TCP 协议上的优化变得小心谨慎，步履维艰。
依赖于操作系统的实现导致协议僵化
TCP 是由操作系统在内核西方栈层面实现的，应用程序只能使用，不能直接修改。虽然应用程序的更新迭代非常快速和简单。但是 TCP 的迭代却非常缓慢，原因就是操作系统升级很麻烦。
现在移动终端更加流行，但是移动端部分用户的操作系统升级依然可能滞后数年时间。PC 端的系统升级滞后得更加严重，windows xp 现在还有大量用户在使用，尽管它已经存在快 20 年。
服务端系统不依赖用户升级，但是由于操作系统升级涉及到底层软件和运行库的更新，所以也比较保守和缓慢。
这也就意味着即使 TCP 有比较好的特性更新，也很难快速推广。比如 TCP Fast Open。它虽然 2013 年就被提出了，但是 Windows 很多系统版本依然不支持它。
建立连接的握手延迟大
不管是 HTTP1.0/1.1 还是 HTTPS，HTTP2，都使用了 TCP 进行传输。HTTPS 和 HTTP2 还需要使用 TLS 协议来进行安全传输。这就出现了两个握手延迟：
1.TCP 三次握手导致的 TCP 连接建立的延迟。
2.TLS 完全握手需要至少 2 个 RTT 才能建立，简化握手需要 1 个 RTT 的握手延迟。
对于很多短连接场景，这样的握手延迟影响很大，且无法消除。
队头阻塞
队头阻塞主要是 TCP 协议的可靠性机制引入的。TCP 使用序列号来标识数据的顺序，数据必须按照顺序处理，如果前面的数据丢失，后面的数据就算到达了也不会通知应用层来处理。
另外 TLS 协议层面也有一个队头阻塞，因为 TLS 协议都是按照 record 来处理数据的，如果一个 record 中丢失了数据，也会导致整个 record 无法正确处理。
概括来讲，TCP 和 TLS1.2 之前的协议存在着结构性的问题，如果继续在现有的 TCP、TLS 协议之上实现一个全新的应用层协议，依赖于操作系统、中间设备还有用户的支持。部署成本非常高，阻力非常大。
所以 QUIC 协议选择了 UDP，因为 UDP 本身没有连接的概念，不需要三次握手，优化了连接建立的握手延迟，同时在应用程序层面实现了 TCP 的可靠性，TLS 的安全性和 HTTP2 的并发性，只需要用户端和服务端的应用程序支持 QUIC 协议，完全避开了操作系统和中间设备的限制。
QUIC 核心特性连接建立延时低
0RTT 建连可以说是 QUIC 相比 HTTP2 最大的性能优势。那什么是 0RTT 建连呢?这里面有两层含义。
传输层 0RTT 就能建立连接。
加密层 0RTT 就能建立加密连接。
图 1 HTTPS 及 QUIC 建连过程
比如上图左边是 HTTPS 的一次完全握手的建连过程，需要 3 个 RTT。就算是 Session Resumption[14]，也需要至少 2 个 RTT。
而 QUIC 呢?由于建立在 UDP 的基础上，同时又实现了 0RTT 的安全握手，所以在大部分情况下，只需要 0 个 RTT 就能实现数据发送，在实现前向加密 [15] 的基础上，并且 0RTT 的成功率相比 TLS 的 Sesison Ticket[13] 要高很多。
改进的拥塞控制
TCP 的拥塞控制实际上包含了四个算法：慢启动，拥塞避免，快速重传，快速恢复 [22]。
QUIC 协议当前默认使用了 TCP 协议的 Cubic 拥塞控制算法 [6]，同时也支持 CubicBytes, Reno, RenoBytes, BBR, PCC 等拥塞控制算法。
从拥塞算法本身来看，QUIC 只是按照 TCP 协议重新实现了一遍，那么 QUIC 协议到底改进在哪些方面呢?主要有如下几点：
可插拔
什么叫可插拔呢?就是能够非常灵活地生效，变更和停止。体现在如下方面：
应用程序层面就能实现不同的拥塞控制算法，不需要操作系统，不需要内核支持。这是一个飞跃，因为传统的 TCP 拥塞控制，必须要端到端的网络协议栈支持，才能实现控制效果。而内核和操作系统的部署成本非常高，升级周期很长，这在产品快速迭代，网络爆炸式增长的今天，显然有点满足不了需求。
即使是单个应用程序的不同连接也能支持配置不同的拥塞控制。就算是一台服务器，接入的用户网络环境也千差万别，结合大数据及人工智能处理，我们能为各个用户提供不同的但又更加精准更加有效的拥塞控制。比如 BBR 适合，Cubic 适合。
应用程序不需要停机和升级就能实现拥塞控制的变更，我们在服务端只需要修改一下配置，reload 一下，完全不需要停止服务就能实现拥塞控制的切换。
STGW 在配置层面进行了优化，我们可以针对不同业务，不同网络制式，甚至不同的 RTT，使用不同的拥塞控制算法。
单调递增的 Packet Number
TCP 为了保证可靠性，使用了基于字节序号的 Sequence Number 及 Ack 来确认消息的有序到达。
QUIC 同样是一个可靠的协议，它使用 Packet Number 代替了 TCP 的 sequence number，并且每个 Packet Number 都严格递增，也就是说就算 Packet N 丢失了，重传的 Packet N 的 Packet Number 已经不是 N，而是一个比 N 大的值。而 TCP 呢，重传 segment 的 sequence number 和原始的 segment 的 Sequence Number 保持不变，也正是由于这个特性，引入了 Tcp 重传的歧义问题。
图 2 Tcp 重传歧义性
如上图所示，超时事件 RTO 发生后，客户端发起重传，然后接收到了 Ack 数据。由于序列号一样，这个 Ack 数据到底是原始请求的响应还是重传请求的响应呢?不好判断。
如果算成原始请求的响应，但实际上是重传请求的响应(上图左)，会导致采样 RTT 变大。如果算成重传请求的响应，但实际上是原始请求的响应，又很容易导致采样 RTT 过小。
由于 Quic 重传的 Packet 和原始 Packet 的 Pakcet Number 是严格递增的，所以很容易就解决了这个问题。
图 3 Quic 重传没有歧义性
如上图所示，RTO 发生后，根据重传的 Packet Number 就能确定精确的 RTT 计算。如果 Ack 的 Packet Number 是 N+M，就根据重传请求计算采样 RTT。如果 Ack 的 Pakcet Number 是 N，就根据原始请求的时间计算采样 RTT，没有歧义性。
但是单纯依靠严格递增的 Packet Number 肯定是无法保证数据的顺序性和可靠性。QUIC 又引入了一个 Stream Offset 的概念。
即一个 Stream 可以经过多个 Packet 传输，Packet Number 严格递增，没有依赖。但是 Packet 里的 Payload 如果是 Stream 的话，就需要依靠 Stream 的 Offset 来保证应用数据的顺序。如错误! 未找到引用源。所示，发送端先后发送了 Pakcet N 和 Pakcet N+1，Stream 的 Offset 分别是 x 和 x+y。
假设 Packet N 丢失了，发起重传，重传的 Packet Number 是 N+2，但是它的 Stream 的 Offset 依然是 x，这样就算 Packet N + 2 是后到的，依然可以将 Stream x 和 Stream x+y 按照顺序组织起来，交给应用程序处理。
图 4 Stream Offset 保证有序性
不允许 Reneging
什么叫 Reneging 呢?就是接收方丢弃已经接收并且上报给 SACK 选项的内容 [8]。TCP 协议不鼓励这种行为，但是协议层面允许这样的行为。主要是考虑到服务器资源有限，比如 Buffer 溢出，内存不够等情况。
Reneging 对数据重传会产生很大的干扰。因为 Sack 都已经表明接收到了，但是接收端事实上丢弃了该数据。
QUIC 在协议层面禁止 Reneging，一个 Packet 只要被 Ack，就认为它一定被正确接收，减少了这种干扰。
更多的 Ack 块
TCP 的 Sack 选项能够告诉发送方已经接收到的连续 Segment 的范围，方便发送方进行选择性重传。
由于 TCP 头部最大只有 60 个字节，标准头部占用了 20 字节，所以 Tcp Option 最大长度只有 40 字节，再加上 Tcp Timestamp option 占用了 10 个字节 [25]，所以留给 Sack 选项的只有 30 个字节。
每一个 Sack Block 的长度是 8 个，加上 Sack Option 头部 2 个字节，也就意味着 Tcp Sack Option 最大只能提供 3 个 Block。
但是 Quic Ack Frame 可以同时提供 256 个 Ack Block，在丢包率比较高的网络下，更多的 Sack Block 可以提升网络的恢复速度，减少重传量。
Ack Delay 时间
Tcp 的 Timestamp 选项存在一个问题 [25]，它只是回显了发送方的时间戳，但是没有计算接收端接收到 segment 到发送 Ack 该 segment 的时间。这个时间可以简称为 Ack Delay。
这样就会导致 RTT 计算误差。如下图：
可以认为 TCP 的 RTT 计算：
而 Quic 计算如下：
当然 RTT 的具体计算没有这么简单，需要采样，参考历史数值进行平滑计算，参考如下公式 [9]。
基于 stream 和 connecton 级别的流量控制
QUIC 的流量控制 [22] 类似 HTTP2，即在 Connection 和 Stream 级别提供了两种流量控制。为什么需要两类流量控制呢?主要是因为 QUIC 支持多路复用。
Stream 可以认为就是一条 HTTP 请求。
Connection 可以类比一条 TCP 连接。多路复用意味着在一条 Connetion 上会同时存在多条 Stream。既需要对单个 Stream 进行控制，又需要针对所有 Stream 进行总体控制。
QUIC 实现流量控制的原理比较简单：
通过 window_update 帧告诉对端自己可以接收的字节数，这样发送方就不会发送超过这个数量的数据。
通过 BlockFrame 告诉对端由于流量控制被阻塞了，无法发送数据。
QUIC 的流量控制和 TCP 有点区别，TCP 为了保证可靠性，窗口左边沿向右滑动时的长度取决于已经确认的字节数。如果中间出现丢包，就算接收到了更大序号的 Segment，窗口也无法超过这个序列号。
但 QUIC 不同，就算此前有些 packet 没有接收到，它的滑动只取决于接收到的最大偏移字节数。
图 5 Quic Flow Control针对 Stream：
针对 Connection：
同样地，STGW 也在连接和 Stream 级别设置了不同的窗口数。
最重要的是，我们可以在内存不足或者上游处理性能出现问题时，通过流量控制来限制传输速率，保障服务可用性。
没有队头阻塞的多路复用
QUIC 的多路复用和 HTTP2 类似。在一条 QUIC 连接上可以并发发送多个 HTTP 请求 (stream)。但是 QUIC 的多路复用相比 HTTP2 有一个很大的优势。
QUIC 一个连接上的多个 stream 之间没有依赖。这样假如 stream2 丢了一个 udp packet，也只会影响 stream2 的处理。不会影响 stream2 之前及之后的 stream 的处理。
这也就在很大程度上缓解甚至消除了队头阻塞的影响。
多路复用是 HTTP2 最强大的特性 [7]，能够将多条请求在一条 TCP 连接上同时发出去。但也恶化了 TCP 的一个问题，队头阻塞 [11]，如下图示：
图 6 HTTP2 队头阻塞
HTTP2 在一个 TCP 连接上同时发送 4 个 Stream。其中 Stream1 已经正确到达，并被应用层读取。但是 Stream2 的第三个 tcp segment 丢失了，TCP 为了保证数据的可靠性，需要发送端重传第 3 个 segment 才能通知应用层读取接下去的数据，虽然这个时候 Stream3 和 Stream4 的全部数据已经到达了接收端，但都被阻塞住了。
不仅如此，由于 HTTP2 强制使用 TLS，还存在一个 TLS 协议层面的队头阻塞 [12]。
图 7 TLS 队头阻塞
Record 是 TLS 协议处理的最小单位，最大不能超过 16K，一些服务器比如 Nginx 默认的大小就是 16K。由于一个 record 必须经过数据一致性校验才能进行加解密，所以一个 16K 的 record，就算丢了一个字节，也会导致已经接收到的 15.99K 数据无法处理，因为它不完整。
那 QUIC 多路复用为什么能避免上述问题呢?
QUIC 最基本的传输单元是 Packet，不会超过 MTU 的大小，整个加密和认证过程都是基于 Packet 的，不会跨越多个 Packet。这样就能避免 TLS 协议存在的队头阻塞。
Stream 之间相互独立，比如 Stream2 丢了一个 Pakcet，不会影响 Stream3 和 Stream4。不存在 TCP 队头阻塞。
图 8 QUIC 多路复用时没有队头阻塞的问题
当然，并不是所有的 QUIC 数据都不会受到队头阻塞的影响，比如 QUIC 当前也是使用 Hpack 压缩算法 [10]，由于算法的限制，丢失一个头部数据时，可能遇到队头阻塞。
总体来说，QUIC 在传输大量数据时，比如视频，受到队头阻塞的影响很小。
加密认证的报文
TCP 协议头部没有经过任何加密和认证，所以在传输过程中很容易被中间网络设备篡改，注入和窃听。比如修改序列号、滑动窗口。这些行为有可能是出于性能优化，也有可能是主动攻击。
但是 QUIC 的 packet 可以说是武装到了牙齿。除了个别报文比如 PUBLIC_RESET 和 CHLO，所有报文头部都是经过认证的，报文 Body 都是经过加密的。
这样只要对 QUIC 报文任何修改，接收端都能够及时发现，有效地降低了安全风险。
如下图所示，红色部分是 Stream Frame 的报文头部，有认证。绿色部分是报文内容，全部经过加密。
连接迁移
一条 TCP 连接 [17] 是由四元组标识的(源 IP，源端口，目的 IP，目的端口)。什么叫连接迁移呢?就是当其中任何一个元素发生变化时，这条连接依然维持着，能够保持业务逻辑不中断。当然这里面主要关注的是客户端的变化，因为客户端不可控并且网络环境经常发生变化，而服务端的 IP 和端口一般都是固定的。
比如大家使用手机在 WIFI 和 4G 移动网络切换时，客户端的 IP 肯定会发生变化，需要重新建立和服务端的 TCP 连接。
又比如大家使用公共 NAT 出口时，有些连接竞争时需要重新绑定端口，导致客户端的端口发生变化，同样需要重新建立 TCP 连接。
针对 TCP 的连接变化，MPTCP[5] 其实已经有了解决方案，但是由于 MPTCP 需要操作系统及网络协议栈支持，部署阻力非常大，目前并不适用。
所以从 TCP 连接的角度来讲，这个问题是无解的。
那 QUIC 是如何做到连接迁移呢?很简单，任何一条 QUIC 连接不再以 IP 及端口四元组标识，而是以一个 64 位的随机数作为 ID 来标识，这样就算 IP 或者端口发生变化时，只要 ID 不变，这条连接依然维持着，上层业务逻辑感知不到变化，不会中断，也就不需要重连。
由于这个 ID 是客户端随机产生的，并且长度有 64 位，所以冲突概率非常低。
其他亮点
此外，QUIC 还能实现前向冗余纠错，在重要的包比如握手消息发生丢失时，能够根据冗余信息还原出握手消息。
QUIC 还能实现证书压缩，减少证书传输量，针对包头进行验证等。
限于篇幅，本文不再详细介绍，有兴趣的可以参考文档 [23] 和文档 [4] 和文档 [26]。
参考线索
[1]. https://www.chromium.org/quic
[2]. https://docs.google.com/docume ... /edit
[3]. E. Rescorla, “The Transport Layer Security (TLS) Protocol Version 1.3”, draft-ietf-tls-tls13-21, https://tools.ietf.org/html/dr ... 13-21, July 03, 2017
[4]. Adam Langley,Wan-Teh Chang, “QUIC Crypto”，https://docs.google.com/docume ... /edit, 20161206
[5]. https://www.multipath-tcp.org/
[6]. Ha, S., Rhee, I., and L. Xu, "CUBIC: A New TCP-Friendly High-Speed TCP Variant", ACM SIGOPS Operating System Review , 2008.
[7]. M. Belshe,BitGo, R. Peon, “Hypertext Transfer Protocol Version 2 (HTTP/2)”, RFC 7540, May 2015
[8]. M. Mathis,J. Mahdavi,S. Floyd,A. Romanow,“TCP Selective Acknowledgment Options”, rfc2018, https://tools.ietf.org/html/rfc2018, October 1996
[9]. V. Paxson，M. Allman，J. Chu，M. Sargent，“Computing TCP's Retransmission Timer”， rfc6298, https://tools.ietf.org/html/rfc6298, June 2011
[10]. R. Peon,H. Ruellan,“HPACK: Header Compression for HTTP/2”,RFC7541,May 2015
[11]. M. Scharf, Alcatel-Lucent Bell Labs, S. Kiesel, “Quantifying Head-of-Line Blocking in TCP and SCTP”, https://tools.ietf.org/id/draf ... .html, July 15, 2013
[12]. Ilya Grigorik，“Optimizing TLS Record Size & Buffering Latency”, https://www.igvita.com/2013/10 ... ency/, October 24, 2013
[13]. J. Salowey,H. Zhou,P. Eronen,H. Tschofenig, “Transport Layer Security (TLS) Session Resumption without Server-Side State”, RFC5077, January 2008
[14]. Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, DOI 10.17487/RFC5246, August 2008, .
[15]. Shirey, R., "Internet Security Glossary, Version 2", FYI , RFC 4949, August 2007
[16]. 罗成，“HTTPS性能优化”， http://www.infoq.com/cn/presen ... https，February.2017
[17]. Postel, J., "Transmission Control Protocol", STD 7, RFC793, September 1981.
[18]. J. Postel,“User Datagram Protocol”, RFC768,August 1980
[19]. Q. Dang, S. Santesson,K. Moriarty,D. Brown.T. Polk, “Internet X.509 Public Key Infrastructure: Additional Algorithms and Identifiers for DSA and ECDSA”,RFC5758, January 2010
[20]. Bassham, L., Polk, W., and R. Housley, "Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 3279, April 2002
[21]. D.Cooper,S.Santesson, S.Farrell,S. Boeyen,R. Housley,W.Polk, “Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile”, RFC5280, May 2008
[22]. M. Allman,V. Paxson,E. Blanton, "TCP Congestion Control”,RFC5681, September 2009
[23]. Robbie Shade, “Flow control in QUIC”, https://docs.google.com/docume ... it%23, May, 2016,
[24]. ianswett , “QUIC fec v1”, https://docs.google.com/docume ... tytjt, 2016-02-19
[25]. D.Borman,B.Braden,V.Jacobson,R.Scheffenegger, Ed. “TCP Extensions for High Performance”,rfc7323, https://tools.ietf.org/html/rfc7323,September 2014
[26]. 罗成，“WEB加速，协议先行”， https://zhuanlan.zhihu.com/p/27938635，july, 2017
本文主要介绍 QUIC 协议产生的背景和核心特性。
写在前面
如果你的 App，在不需要任何修改的情况下就能提升 15% 以上的访问速度。特别是弱网络的时候能够提升 20% 以上的访问速度。
如果你的 App，在频繁切换 4G 和 WIFI 网络的情况下，不会断线，不需要重连，用户无任何感知。如果你的 App，既需要 TLS 的安全，也想实现 HTTP2 多路复用的强大。
如果你刚刚才听说 HTTP2 是下一代互联网协议，如果你刚刚才关注到 TLS1.3 是一个革命性具有里程碑意义的协议，但是这两个协议却一直在被另一个更新兴的协议所影响和挑战。
如果这个新兴的协议，它的名字就叫做“快”，并且正在标准化为新一代的互联网传输协议。
你愿意花一点点时间了解这个协议吗?你愿意投入精力去研究这个协议吗?你愿意全力推动业务来使用这个协议吗?
QUIC 概述
Quic 全称 quick udp internet connection [1]，“快速 UDP 互联网连接”，(和英文 quick 谐音，简称“快”)是由 google 提出的使用 udp 进行多路并发传输的协议。
Quic 相比现在广泛应用的 http2+tcp+tls 协议有如下优势 [2]：
减少了 TCP 三次握手及 TLS 握手时间。
改进的拥塞控制。
避免队头阻塞的多路复用。
连接迁移。
前向冗余纠错。
为什么需要 QUIC
从上个世纪 90 年代互联网开始兴起一直到现在，大部分的互联网流量传输只使用了几个网络协议。使用 IPv4 进行路由，使用 TCP 进行连接层面的流量控制，使用 SSL/TLS 协议实现传输安全，使用 DNS 进行域名解析，使用 HTTP 进行应用数据的传输。
而且近三十年来，这几个协议的发展都非常缓慢。TCP 主要是拥塞控制算法的改进，SSL/TLS 基本上停留在原地，几个小版本的改动主要是密码套件的升级，TLS1.3[3] 是一个飞跃式的变化，但截止到今天，还没有正式发布。IPv4 虽然有一个大的进步，实现了 IPv6，DNS 也增加了一个安全的 DNSSEC，但和 IPv6 一样，部署进度较慢。
随着移动互联网快速发展以及物联网的逐步兴起，网络交互的场景越来越丰富，网络传输的内容也越来越庞大，用户对网络传输效率和 WEB 响应速度的要求也越来越高。
一方面是历史悠久使用广泛的古老协议，另外一方面用户的使用场景对传输性能的要求又越来越高。如下几个由来已久的问题和矛盾就变得越来越突出。
协议历史悠久导致中间设备僵化。
依赖于操作系统的实现导致协议本身僵化。
建立连接的握手延迟大。
队头阻塞。
这里分小节简单说明一下：
中间设备的僵化
可能是 TCP 协议使用得太久，也非常可靠。所以我们很多中间设备，包括防火墙、NAT 网关，整流器等出现了一些约定俗成的动作。
比如有些防火墙只允许通过 80 和 443，不放通其他端口。NAT 网关在转换网络地址时重写传输层的头部，有可能导致双方无法使用新的传输格式。整流器和中间代理有时候出于安全的需要，会删除一些它们不认识的选项字段。
TCP 协议本来是支持端口、选项及特性的增加和修改。但是由于 TCP 协议和知名端口及选项使用的历史太悠久，中间设备已经依赖于这些潜规则，所以对这些内容的修改很容易遭到中间环节的干扰而失败。
而这些干扰，也导致很多在 TCP 协议上的优化变得小心谨慎，步履维艰。
依赖于操作系统的实现导致协议僵化
TCP 是由操作系统在内核西方栈层面实现的，应用程序只能使用，不能直接修改。虽然应用程序的更新迭代非常快速和简单。但是 TCP 的迭代却非常缓慢，原因就是操作系统升级很麻烦。
现在移动终端更加流行，但是移动端部分用户的操作系统升级依然可能滞后数年时间。PC 端的系统升级滞后得更加严重，windows xp 现在还有大量用户在使用，尽管它已经存在快 20 年。
服务端系统不依赖用户升级，但是由于操作系统升级涉及到底层软件和运行库的更新，所以也比较保守和缓慢。
这也就意味着即使 TCP 有比较好的特性更新，也很难快速推广。比如 TCP Fast Open。它虽然 2013 年就被提出了，但是 Windows 很多系统版本依然不支持它。
建立连接的握手延迟大
不管是 HTTP1.0/1.1 还是 HTTPS，HTTP2，都使用了 TCP 进行传输。HTTPS 和 HTTP2 还需要使用 TLS 协议来进行安全传输。这就出现了两个握手延迟：
1.TCP 三次握手导致的 TCP 连接建立的延迟。
2.TLS 完全握手需要至少 2 个 RTT 才能建立，简化握手需要 1 个 RTT 的握手延迟。
对于很多短连接场景，这样的握手延迟影响很大，且无法消除。
队头阻塞
队头阻塞主要是 TCP 协议的可靠性机制引入的。TCP 使用序列号来标识数据的顺序，数据必须按照顺序处理，如果前面的数据丢失，后面的数据就算到达了也不会通知应用层来处理。
另外 TLS 协议层面也有一个队头阻塞，因为 TLS 协议都是按照 record 来处理数据的，如果一个 record 中丢失了数据，也会导致整个 record 无法正确处理。
概括来讲，TCP 和 TLS1.2 之前的协议存在着结构性的问题，如果继续在现有的 TCP、TLS 协议之上实现一个全新的应用层协议，依赖于操作系统、中间设备还有用户的支持。部署成本非常高，阻力非常大。
所以 QUIC 协议选择了 UDP，因为 UDP 本身没有连接的概念，不需要三次握手，优化了连接建立的握手延迟，同时在应用程序层面实现了 TCP 的可靠性，TLS 的安全性和 HTTP2 的并发性，只需要用户端和服务端的应用程序支持 QUIC 协议，完全避开了操作系统和中间设备的限制。
QUIC 核心特性连接建立延时低
0RTT 建连可以说是 QUIC 相比 HTTP2 最大的性能优势。那什么是 0RTT 建连呢?这里面有两层含义。
传输层 0RTT 就能建立连接。
加密层 0RTT 就能建立加密连接。
图 1 HTTPS 及 QUIC 建连过程
比如上图左边是 HTTPS 的一次完全握手的建连过程，需要 3 个 RTT。就算是 Session Resumption[14]，也需要至少 2 个 RTT。
而 QUIC 呢?由于建立在 UDP 的基础上，同时又实现了 0RTT 的安全握手，所以在大部分情况下，只需要 0 个 RTT 就能实现数据发送，在实现前向加密 [15] 的基础上，并且 0RTT 的成功率相比 TLS 的 Sesison Ticket[13] 要高很多。
改进的拥塞控制
TCP 的拥塞控制实际上包含了四个算法：慢启动，拥塞避免，快速重传，快速恢复 [22]。
QUIC 协议当前默认使用了 TCP 协议的 Cubic 拥塞控制算法 [6]，同时也支持 CubicBytes, Reno, RenoBytes, BBR, PCC 等拥塞控制算法。
从拥塞算法本身来看，QUIC 只是按照 TCP 协议重新实现了一遍，那么 QUIC 协议到底改进在哪些方面呢?主要有如下几点：
可插拔
什么叫可插拔呢?就是能够非常灵活地生效，变更和停止。体现在如下方面：
应用程序层面就能实现不同的拥塞控制算法，不需要操作系统，不需要内核支持。这是一个飞跃，因为传统的 TCP 拥塞控制，必须要端到端的网络协议栈支持，才能实现控制效果。而内核和操作系统的部署成本非常高，升级周期很长，这在产品快速迭代，网络爆炸式增长的今天，显然有点满足不了需求。
即使是单个应用程序的不同连接也能支持配置不同的拥塞控制。就算是一台服务器，接入的用户网络环境也千差万别，结合大数据及人工智能处理，我们能为各个用户提供不同的但又更加精准更加有效的拥塞控制。比如 BBR 适合，Cubic 适合。
应用程序不需要停机和升级就能实现拥塞控制的变更，我们在服务端只需要修改一下配置，reload 一下，完全不需要停止服务就能实现拥塞控制的切换。
STGW 在配置层面进行了优化，我们可以针对不同业务，不同网络制式，甚至不同的 RTT，使用不同的拥塞控制算法。
单调递增的 Packet Number
TCP 为了保证可靠性，使用了基于字节序号的 Sequence Number 及 Ack 来确认消息的有序到达。
QUIC 同样是一个可靠的协议，它使用 Packet Number 代替了 TCP 的 sequence number，并且每个 Packet Number 都严格递增，也就是说就算 Packet N 丢失了，重传的 Packet N 的 Packet Number 已经不是 N，而是一个比 N 大的值。而 TCP 呢，重传 segment 的 sequence number 和原始的 segment 的 Sequence Number 保持不变，也正是由于这个特性，引入了 Tcp 重传的歧义问题。
图 2 Tcp 重传歧义性
如上图所示，超时事件 RTO 发生后，客户端发起重传，然后接收到了 Ack 数据。由于序列号一样，这个 Ack 数据到底是原始请求的响应还是重传请求的响应呢?不好判断。
如果算成原始请求的响应，但实际上是重传请求的响应(上图左)，会导致采样 RTT 变大。如果算成重传请求的响应，但实际上是原始请求的响应，又很容易导致采样 RTT 过小。
由于 Quic 重传的 Packet 和原始 Packet 的 Pakcet Number 是严格递增的，所以很容易就解决了这个问题。
图 3 Quic 重传没有歧义性
如上图所示，RTO 发生后，根据重传的 Packet Number 就能确定精确的 RTT 计算。如果 Ack 的 Packet Number 是 N+M，就根据重传请求计算采样 RTT。如果 Ack 的 Pakcet Number 是 N，就根据原始请求的时间计算采样 RTT，没有歧义性。
但是单纯依靠严格递增的 Packet Number 肯定是无法保证数据的顺序性和可靠性。QUIC 又引入了一个 Stream Offset 的概念。
即一个 Stream 可以经过多个 Packet 传输，Packet Number 严格递增，没有依赖。但是 Packet 里的 Payload 如果是 Stream 的话，就需要依靠 Stream 的 Offset 来保证应用数据的顺序。如错误! 未找到引用源。所示，发送端先后发送了 Pakcet N 和 Pakcet N+1，Stream 的 Offset 分别是 x 和 x+y。
假设 Packet N 丢失了，发起重传，重传的 Packet Number 是 N+2，但是它的 Stream 的 Offset 依然是 x，这样就算 Packet N + 2 是后到的，依然可以将 Stream x 和 Stream x+y 按照顺序组织起来，交给应用程序处理。
图 4 Stream Offset 保证有序性
不允许 Reneging
什么叫 Reneging 呢?就是接收方丢弃已经接收并且上报给 SACK 选项的内容 [8]。TCP 协议不鼓励这种行为，但是协议层面允许这样的行为。主要是考虑到服务器资源有限，比如 Buffer 溢出，内存不够等情况。
Reneging 对数据重传会产生很大的干扰。因为 Sack 都已经表明接收到了，但是接收端事实上丢弃了该数据。
QUIC 在协议层面禁止 Reneging，一个 Packet 只要被 Ack，就认为它一定被正确接收，减少了这种干扰。
更多的 Ack 块
TCP 的 Sack 选项能够告诉发送方已经接收到的连续 Segment 的范围，方便发送方进行选择性重传。
由于 TCP 头部最大只有 60 个字节，标准头部占用了 20 字节，所以 Tcp Option 最大长度只有 40 字节，再加上 Tcp Timestamp option 占用了 10 个字节 [25]，所以留给 Sack 选项的只有 30 个字节。
每一个 Sack Block 的长度是 8 个，加上 Sack Option 头部 2 个字节，也就意味着 Tcp Sack Option 最大只能提供 3 个 Block。
但是 Quic Ack Frame 可以同时提供 256 个 Ack Block，在丢包率比较高的网络下，更多的 Sack Block 可以提升网络的恢复速度，减少重传量。
Ack Delay 时间
Tcp 的 Timestamp 选项存在一个问题 [25]，它只是回显了发送方的时间戳，但是没有计算接收端接收到 segment 到发送 Ack 该 segment 的时间。这个时间可以简称为 Ack Delay。
这样就会导致 RTT 计算误差。如下图：
可以认为 TCP 的 RTT 计算：
而 Quic 计算如下：
当然 RTT 的具体计算没有这么简单，需要采样，参考历史数值进行平滑计算，参考如下公式 [9]。
基于 stream 和 connecton 级别的流量控制
QUIC 的流量控制 [22] 类似 HTTP2，即在 Connection 和 Stream 级别提供了两种流量控制。为什么需要两类流量控制呢?主要是因为 QUIC 支持多路复用。
Stream 可以认为就是一条 HTTP 请求。
Connection 可以类比一条 TCP 连接。多路复用意味着在一条 Connetion 上会同时存在多条 Stream。既需要对单个 Stream 进行控制，又需要针对所有 Stream 进行总体控制。
QUIC 实现流量控制的原理比较简单：
通过 window_update 帧告诉对端自己可以接收的字节数，这样发送方就不会发送超过这个数量的数据。
通过 BlockFrame 告诉对端由于流量控制被阻塞了，无法发送数据。
QUIC 的流量控制和 TCP 有点区别，TCP 为了保证可靠性，窗口左边沿向右滑动时的长度取决于已经确认的字节数。如果中间出现丢包，就算接收到了更大序号的 Segment，窗口也无法超过这个序列号。
但 QUIC 不同，就算此前有些 packet 没有接收到，它的滑动只取决于接收到的最大偏移字节数。
图 5 Quic Flow Control针对 Stream：
针对 Connection：
同样地，STGW 也在连接和 Stream 级别设置了不同的窗口数。
最重要的是，我们可以在内存不足或者上游处理性能出现问题时，通过流量控制来限制传输速率，保障服务可用性。
没有队头阻塞的多路复用
QUIC 的多路复用和 HTTP2 类似。在一条 QUIC 连接上可以并发发送多个 HTTP 请求 (stream)。但是 QUIC 的多路复用相比 HTTP2 有一个很大的优势。
QUIC 一个连接上的多个 stream 之间没有依赖。这样假如 stream2 丢了一个 udp packet，也只会影响 stream2 的处理。不会影响 stream2 之前及之后的 stream 的处理。
这也就在很大程度上缓解甚至消除了队头阻塞的影响。
多路复用是 HTTP2 最强大的特性 [7]，能够将多条请求在一条 TCP 连接上同时发出去。但也恶化了 TCP 的一个问题，队头阻塞 [11]，如下图示：
图 6 HTTP2 队头阻塞
HTTP2 在一个 TCP 连接上同时发送 4 个 Stream。其中 Stream1 已经正确到达，并被应用层读取。但是 Stream2 的第三个 tcp segment 丢失了，TCP 为了保证数据的可靠性，需要发送端重传第 3 个 segment 才能通知应用层读取接下去的数据，虽然这个时候 Stream3 和 Stream4 的全部数据已经到达了接收端，但都被阻塞住了。
不仅如此，由于 HTTP2 强制使用 TLS，还存在一个 TLS 协议层面的队头阻塞 [12]。
图 7 TLS 队头阻塞
Record 是 TLS 协议处理的最小单位，最大不能超过 16K，一些服务器比如 Nginx 默认的大小就是 16K。由于一个 record 必须经过数据一致性校验才能进行加解密，所以一个 16K 的 record，就算丢了一个字节，也会导致已经接收到的 15.99K 数据无法处理，因为它不完整。
那 QUIC 多路复用为什么能避免上述问题呢?
QUIC 最基本的传输单元是 Packet，不会超过 MTU 的大小，整个加密和认证过程都是基于 Packet 的，不会跨越多个 Packet。这样就能避免 TLS 协议存在的队头阻塞。
Stream 之间相互独立，比如 Stream2 丢了一个 Pakcet，不会影响 Stream3 和 Stream4。不存在 TCP 队头阻塞。
图 8 QUIC 多路复用时没有队头阻塞的问题
当然，并不是所有的 QUIC 数据都不会受到队头阻塞的影响，比如 QUIC 当前也是使用 Hpack 压缩算法 [10]，由于算法的限制，丢失一个头部数据时，可能遇到队头阻塞。
总体来说，QUIC 在传输大量数据时，比如视频，受到队头阻塞的影响很小。
加密认证的报文
TCP 协议头部没有经过任何加密和认证，所以在传输过程中很容易被中间网络设备篡改，注入和窃听。比如修改序列号、滑动窗口。这些行为有可能是出于性能优化，也有可能是主动攻击。
但是 QUIC 的 packet 可以说是武装到了牙齿。除了个别报文比如 PUBLIC_RESET 和 CHLO，所有报文头部都是经过认证的，报文 Body 都是经过加密的。
这样只要对 QUIC 报文任何修改，接收端都能够及时发现，有效地降低了安全风险。
如下图所示，红色部分是 Stream Frame 的报文头部，有认证。绿色部分是报文内容，全部经过加密。
连接迁移
一条 TCP 连接 [17] 是由四元组标识的(源 IP，源端口，目的 IP，目的端口)。什么叫连接迁移呢?就是当其中任何一个元素发生变化时，这条连接依然维持着，能够保持业务逻辑不中断。当然这里面主要关注的是客户端的变化，因为客户端不可控并且网络环境经常发生变化，而服务端的 IP 和端口一般都是固定的。
比如大家使用手机在 WIFI 和 4G 移动网络切换时，客户端的 IP 肯定会发生变化，需要重新建立和服务端的 TCP 连接。
又比如大家使用公共 NAT 出口时，有些连接竞争时需要重新绑定端口，导致客户端的端口发生变化，同样需要重新建立 TCP 连接。
针对 TCP 的连接变化，MPTCP[5] 其实已经有了解决方案，但是由于 MPTCP 需要操作系统及网络协议栈支持，部署阻力非常大，目前并不适用。
所以从 TCP 连接的角度来讲，这个问题是无解的。
那 QUIC 是如何做到连接迁移呢?很简单，任何一条 QUIC 连接不再以 IP 及端口四元组标识，而是以一个 64 位的随机数作为 ID 来标识，这样就算 IP 或者端口发生变化时，只要 ID 不变，这条连接依然维持着，上层业务逻辑感知不到变化，不会中断，也就不需要重连。
由于这个 ID 是客户端随机产生的，并且长度有 64 位，所以冲突概率非常低。
其他亮点
此外，QUIC 还能实现前向冗余纠错，在重要的包比如握手消息发生丢失时，能够根据冗余信息还原出握手消息。
QUIC 还能实现证书压缩，减少证书传输量，针对包头进行验证等。
限于篇幅，本文不再详细介绍，有兴趣的可以参考文档 [23] 和文档 [4] 和文档 [26]。
参考线索
[1]. https://www.chromium.org/quic
[2]. https://docs.google.com/docume ... /edit
[3]. E. Rescorla, “The Transport Layer Security (TLS) Protocol Version 1.3”, draft-ietf-tls-tls13-21, https://tools.ietf.org/html/dr ... 13-21, July 03, 2017
[4]. Adam Langley,Wan-Teh Chang, “QUIC Crypto”，https://docs.google.com/docume ... /edit, 20161206
[5]. https://www.multipath-tcp.org/
[6]. Ha, S., Rhee, I., and L. Xu, "CUBIC: A New TCP-Friendly High-Speed TCP Variant", ACM SIGOPS Operating System Review , 2008.
[7]. M. Belshe,BitGo, R. Peon, “Hypertext Transfer Protocol Version 2 (HTTP/2)”, RFC 7540, May 2015
[8]. M. Mathis,J. Mahdavi,S. Floyd,A. Romanow,“TCP Selective Acknowledgment Options”, rfc2018, https://tools.ietf.org/html/rfc2018, October 1996
[9]. V. Paxson，M. Allman，J. Chu，M. Sargent，“Computing TCP's Retransmission Timer”， rfc6298, https://tools.ietf.org/html/rfc6298, June 2011
[10]. R. Peon,H. Ruellan,“HPACK: Header Compression for HTTP/2”,RFC7541,May 2015
[11]. M. Scharf, Alcatel-Lucent Bell Labs, S. Kiesel, “Quantifying Head-of-Line Blocking in TCP and SCTP”, https://tools.ietf.org/id/draf ... .html, July 15, 2013
[12]. Ilya Grigorik，“Optimizing TLS Record Size & Buffering Latency”, https://www.igvita.com/2013/10 ... ency/, October 24, 2013
[13]. J. Salowey,H. Zhou,P. Eronen,H. Tschofenig, “Transport Layer Security (TLS) Session Resumption without Server-Side State”, RFC5077, January 2008
[14]. Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, DOI 10.17487/RFC5246, August 2008, .
[15]. Shirey, R., "Internet Security Glossary, Version 2", FYI , RFC 4949, August 2007
[16]. 罗成，“HTTPS性能优化”， http://www.infoq.com/cn/presen ... https，February.2017
[17]. Postel, J., "Transmission Control Protocol", STD 7, RFC793, September 1981.
[18]. J. Postel,“User Datagram Protocol”, RFC768,August 1980
[19]. Q. Dang, S. Santesson,K. Moriarty,D. Brown.T. Polk, “Internet X.509 Public Key Infrastructure: Additional Algorithms and Identifiers for DSA and ECDSA”,RFC5758, January 2010
[20]. Bassham, L., Polk, W., and R. Housley, "Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 3279, April 2002
[21]. D.Cooper,S.Santesson, S.Farrell,S. Boeyen,R. Housley,W.Polk, “Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile”, RFC5280, May 2008
[22]. M. Allman,V. Paxson,E. Blanton, "TCP Congestion Control”,RFC5681, September 2009
[23]. Robbie Shade, “Flow control in QUIC”, https://docs.google.com/docume ... it%23, May, 2016,
[24]. ianswett , “QUIC fec v1”, https://docs.google.com/docume ... tytjt, 2016-02-19
[25]. D.Borman,B.Braden,V.Jacobson,R.Scheffenegger, Ed. “TCP Extensions for High Performance”,rfc7323, https://tools.ietf.org/html/rfc7323,September 2014
[26]. 罗成，“WEB加速，协议先行”， https://zhuanlan.zhihu.com/p/27938635，july, 2017
0
评论
Netty实现长连接服务的各种难点和可优化点
beyond 发表了文章 • 364 次浏览 • 2019-11-26 14:47
推送服务
还记得一年半前，做的一个项目需要用到 Android 推送服务。和 iOS 不同，Android 生态中没有统一的推送服务。Google 虽然有 Google Cloud Messaging ，但是连国外都没统一，更别说国内了，直接被墙。
所以之前在 Android 上做推送大部分只能靠轮询。而我们之前在技术调研的时候，搜到了 jPush 的博客，上面介绍了一些他们的技术特点，他们主要做的其实就是移动网络下的长连接服务。单机 50W-100W 的连接的确是吓我一跳！后来我们也采用了他们的免费方案，因为是一个受众面很小的产品，所以他们的免费版够我们用了。一年多下来，运作稳定，非常不错！
时隔两年，换了部门后，竟然接到了一项任务，优化公司自己的长连接服务端。
再次搜索网上技术资料后才发现，相关的很多难点都被攻破，网上也有了很多的总结文章，单机 50W-100W 的连接完全不是梦，其实人人都可以做到。但是光有连接还不够，QPS 也要一起上去。
所以，这篇文章就是汇总一下利用 Netty 实现长连接服务过程中的各种难点和可优化点。
Netty 是什么
Netty: http://netty.io/
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.
官方的解释最精准了，期中最吸引人的就是高性能了。但是很多人会有这样的疑问：直接用 NIO 实现的话，一定会更快吧？就像我直接手写 JDBC 虽然代码量大了点，但是一定比 iBatis 快！
但是，如果了解 Netty 后你才会发现，这个还真不一定！
利用 Netty 而不用 NIO 直接写的优势有这些：
高性能高扩展的架构设计，大部分情况下你只需要关注业务而不需要关注架构
Zero-Copy 技术尽量减少内存拷贝
为 Linux 实现 Native 版 Socket
写同一份代码，兼容 java 1.7 的 NIO2 和 1.7 之前版本的 NIO
Pooled Buffers 大大减轻 Buffer 和释放 Buffer 的压力
……
特性太多，大家可以去看一下《Netty in Action》这本书了解更多。
另外，Netty 源码是一本很好的教科书！大家在使用的过程中可以多看看它的源码，非常棒！
瓶颈是什么
想要做一个长链服务的话，最终的目标是什么？而它的瓶颈又是什么？
其实目标主要就两个：
更多的连接
更高的 QPS
所以，下面就针对这连个目标来说说他们的难点和注意点吧。
更多的连接
非阻塞 IO
其实无论是用 Java NIO 还是用 Netty，达到百万连接都没有任何难度。因为它们都是非阻塞的 IO，不需要为每个连接创建一个线程了。
欲知详情，可以搜索一下BIO,NIO,AIO的相关知识点。
Java NIO 实现百万连接ServerSocketChannel ssc = ServerSocketChannel.open(); Selector sel = Selector.open(); ssc.configureBlocking(false); ssc.socket().bind(new InetSocketAddress(8080)); SelectionKey key = ssc.register(sel, SelectionKey.OP_ACCEPT); while(true) { sel.select(); Iterator it = sel.selectedKeys().iterator(); while(it.hasNext()) { SelectionKey skey = (SelectionKey)it.next(); it.remove(); if(skey.isAcceptable()) { ch = ssc.accept(); } } }这段代码只会接受连过来的连接，不做任何操作，仅仅用来测试待机连接数极限。
大家可以看到这段代码是 NIO 的基本写法，没什么特别的。
Netty 实现百万连接NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoopGroup workerGroup= new NioEventLoopGroup(); ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup); bootstrap.channel( NioServerSocketChannel.class); bootstrap.childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo: add handler }}); bootstrap.bind(8080).sync();这段其实也是非常简单的 Netty 初始化代码。同样，为了实现百万连接根本没有什么特殊的地方。
瓶颈到底在哪
上面两种不同的实现都非常简单，没有任何难度，那有人肯定会问了：实现百万连接的瓶颈到底是什么？
其实只要 java 中用的是非阻塞 IO（NIO 和 AIO 都算），那么它们都可以用单线程来实现大量的 Socket 连接。 不会像 BIO 那样为每个连接创建一个线程，因为代码层面不会成为瓶颈。
其实真正的瓶颈是在 Linux 内核配置上，默认的配置会限制全局最大打开文件数(Max Open Files)还会限制进程数。 所以需要对 Linux 内核配置进行一定的修改才可以。
这个东西现在看似很简单，按照网上的配置改一下就行了，但是大家一定不知道第一个研究这个人有多难。
这里直接贴几篇文章，介绍了相关配置的修改方式：
构建C1000K的服务器
100万并发连接服务器笔记之1M并发连接目标达成
淘宝技术分享 HTTP长连接200万尝试及调优
如何验证
让服务器支持百万连接一点也不难，我们当时很快就搞定了一个测试服务端，但是最大的问题是，我怎么去验证这个服务器可以支撑百万连接呢？
我们用 Netty 写了一个测试客户端，它同样用了非阻塞 IO ，所以不用开大量的线程。 但是一台机器上的端口数是有限制的，用root权限的话，最多也就 6W 多个连接了。 所以我们这里用 Netty 写一个客户端，用尽单机所有的连接吧。NioEventLoopGroup workerGroup = new NioEventLoopGroup(); Bootstrap b = new Bootstrap(); b.group(workerGroup); b.channel( NioSocketChannel.class); b.handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo:add handler } }); for (int k = 0; k < 60000; k++) { //请自行修改成服务端的IP b.connect(127.0.0.1, 8080); }代码同样很简单，只要连上就行了，不需要做任何其他的操作。
这样只要找到一台电脑启动这个程序即可。这里需要注意一点，客户端最好和服务端一样，修改一下 Linux 内核参数配置。
怎么去找那么多机器
按照上面的做法，单机最多可以有 6W 的连接，百万连接起码需要17台机器！
如何才能突破这个限制呢？其实这个限制来自于网卡。 我们后来通过使用虚拟机，并且把虚拟机的虚拟网卡配置成了桥接模式解决了问题。
根据物理机内存大小，单个物理机起码可以跑4-5个虚拟机，所以最终百万连接只要4台物理机就够了。
讨巧的做法
除了用虚拟机充分压榨机器资源外，还有一个非常讨巧的做法，这个做法也是我在验证过程中偶然发现的。
根据 TCP/IP 协议，任何一方发送FIN后就会启动正常的断开流程。而如果遇到网络瞬断的情况，连接并不会自动断开。
那我们是不是可以这样做？
启动服务端，千万别设置 Socket 的keep-alive属性，默认是不设置的
用虚拟机连接服务器
强制关闭虚拟机
修改虚拟机网卡的 MAC 地址，重新启动并连接服务器
服务端接受新的连接，并保持之前的连接不断
我们要验证的是服务端的极限，所以只要一直让服务端认为有那么多连接就行了，不是吗？
经过我们的试验后，这种方法和用真实的机器连接服务端的表现是一样的，因为服务端只是认为对方网络不好罢了，不会将你断开。
另外，禁用keep-alive是因为如果不禁用，Socket 连接会自动探测连接是否可用，如果不可用会强制断开。
更高的 QPS
由于 NIO 和 Netty 都是非阻塞 IO，所以无论有多少连接，都只需要少量的线程即可。而且 QPS 不会因为连接数的增长而降低（在内存足够的前提下）。
而且 Netty 本身设计得足够好了，Netty 不是高 QPS 的瓶颈。那高 QPS 的瓶颈是什么？
是数据结构的设计！
如何优化数据结构
首先要熟悉各种数据结构的特点是必需的，但是在复杂的项目中，不是用了一个集合就可以搞定的，有时候往往是各种集合的组合使用。
既要做到高性能，还要做到一致性，还不能有死锁，这里难度真的不小…
我在这里总结的经验是，不要过早优化。优先考虑一致性，保证数据的准确，然后再去想办法优化性能。
因为一致性比性能重要得多，而且很多性能问题在量小和量大的时候，瓶颈完全会在不同的地方。 所以，我觉得最佳的做法是，编写过程中以一致性为主，性能为辅；代码完成后再去找那个 TOP1，然后去解决它！
解决 CPU 瓶颈
在做这个优化前，先在测试环境中去狠狠地压你的服务器，量小量大，天壤之别。
有了压力测试后，就需要用工具来发现性能瓶颈了！
我喜欢用的是 VisualVM，打开工具后看抽样器(Sample)，根据自用时间(Self Time (CPU))倒序，排名第一的就是你需要去优化的点了！
备注：Sample 和 Profiler 有什么区别？前者是抽样，数据不是最准但是不影响性能；后者是统计准确，但是非常影响性能。 如果你的程序非常耗 CPU，那么尽量用 Sample，否则开启 Profiler 后降低性能，反而会影响准确性。
还记得我们项目第一次发现的瓶颈竟然是ConcurrentLinkedQueue这个类中的size()方法。 量小的时候没有影响，但是Queue很大的时候，它每次都是从头统计总数的，而这个size()方法我们又是非常频繁地调用的，所以对性能产生了影响。
size()的实现如下：public int size() { int count = 0; for (Node<E> p = first(); p != null; p = succ(p)) if (p.item != null) // Collection.size() spec says to max out if (++count == Integer.MAX_VALUE) break; return count; }后来我们通过额外使用一个AtomicInteger来计数，解决了问题。但是分离后岂不是做不到高一致性呢？ 没关系，我们的这部分代码关心最终一致性，所以只要保证最终一致就可以了。
总之，具体案例要具体分析，不同的业务要用不同的实现。
解决 GC 瓶颈
GC 瓶颈也是 CPU 瓶颈的一部分，因为不合理的 GC 会大大影响 CPU 性能。
这里还是在用 VisualVM，但是你需要装一个插件：VisualGC
有了这个插件后，你就可以直观的看到 GC 活动情况了。
按照我们的理解，在压测的时候，有大量的 New GC 是很正常的，因为有大量的对象在创建和销毁。
但是一开始有很多 Old GC 就有点说不过去了！
后来发现，在我们压测环境中，因为 Netty 的 QPS 和连接数关联不大，所以我们只连接了少量的连接。内存分配得也不是很多。
而 JVM 中，默认的新生代和老生代的比例是1:2，所以大量的老生代被浪费了，新生代不够用。
通过调整 -XX:NewRatio 后，Old GC 有了显著的降低。
但是，生产环境又不一样了，生产环境不会有那么大的 QPS，但是连接会很多，连接相关的对象存活时间非常长，所以生产环境更应该分配更多的老生代。
总之，GC 优化和 CPU 优化一样，也需要不断调整，不断优化，不是一蹴而就的。
其他优化
如果你已经完成了自己的程序，那么一定要看看《Netty in Action》作者的这个网站：Netty Best Practices a.k.a Faster == Better。
相信你会受益匪浅，经过里面提到的一些小小的优化后，我们的整体 QPS 提升了很多。
最后一点就是，java 1.7 比 java 1.6 性能高很多！因为 Netty 的编写风格是事件机制的，看似是 AIO。 可 java 1.6 是没有 AIO 的，java 1.7 是支持 AIO 的，所以如果用 java 1.7 的话，性能也会有显著提升。
最后成果
经过几周的不断压测和不断优化了，我们在一台16核、120G内存(JVM只分配8G)的机器上，用 java 1.6 达到了60万的连接和20万的QPS。
其实这还不是极限，JVM 只分配了8G内存，内存配置再大一点连接数还可以上去；
QPS 看似很高，System Load Average 很低，也就是说明瓶颈不在 CPU 也不在内存，那么应该是在 IO 了！ 上面的 Linux 配置是为了达到百万连接而配置的，并没有针对我们自己的业务场景去做优化。
因为目前性能完全够用，线上单机 QPS 最多才 1W，所以我们先把精力放在了其他地方。 相信后面我们还会去继续优化这块的性能，期待 QPS 能有更大的突破！
本作品由 Dozer 创作，采用 知识共享署名-非商业性使用 4.0 国际许可协议 进行许可。 查看全部
还记得一年半前，做的一个项目需要用到 Android 推送服务。和 iOS 不同，Android 生态中没有统一的推送服务。Google 虽然有 Google Cloud Messaging ，但是连国外都没统一，更别说国内了，直接被墙。
所以之前在 Android 上做推送大部分只能靠轮询。而我们之前在技术调研的时候，搜到了 jPush 的博客，上面介绍了一些他们的技术特点，他们主要做的其实就是移动网络下的长连接服务。单机 50W-100W 的连接的确是吓我一跳！后来我们也采用了他们的免费方案，因为是一个受众面很小的产品，所以他们的免费版够我们用了。一年多下来，运作稳定，非常不错！
时隔两年，换了部门后，竟然接到了一项任务，优化公司自己的长连接服务端。
再次搜索网上技术资料后才发现，相关的很多难点都被攻破，网上也有了很多的总结文章，单机 50W-100W 的连接完全不是梦，其实人人都可以做到。但是光有连接还不够，QPS 也要一起上去。
所以，这篇文章就是汇总一下利用 Netty 实现长连接服务过程中的各种难点和可优化点。
Netty 是什么
Netty: http://netty.io/
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.
官方的解释最精准了，期中最吸引人的就是高性能了。但是很多人会有这样的疑问：直接用 NIO 实现的话，一定会更快吧？就像我直接手写 JDBC 虽然代码量大了点，但是一定比 iBatis 快！
但是，如果了解 Netty 后你才会发现，这个还真不一定！
利用 Netty 而不用 NIO 直接写的优势有这些：
高性能高扩展的架构设计，大部分情况下你只需要关注业务而不需要关注架构
Zero-Copy 技术尽量减少内存拷贝
为 Linux 实现 Native 版 Socket
写同一份代码，兼容 java 1.7 的 NIO2 和 1.7 之前版本的 NIO
Pooled Buffers 大大减轻 Buffer 和释放 Buffer 的压力
……
特性太多，大家可以去看一下《Netty in Action》这本书了解更多。
另外，Netty 源码是一本很好的教科书！大家在使用的过程中可以多看看它的源码，非常棒！
瓶颈是什么
想要做一个长链服务的话，最终的目标是什么？而它的瓶颈又是什么？
其实目标主要就两个：
更多的连接
更高的 QPS
所以，下面就针对这连个目标来说说他们的难点和注意点吧。
更多的连接
非阻塞 IO
其实无论是用 Java NIO 还是用 Netty，达到百万连接都没有任何难度。因为它们都是非阻塞的 IO，不需要为每个连接创建一个线程了。
欲知详情，可以搜索一下BIO,NIO,AIO的相关知识点。
Java NIO 实现百万连接ServerSocketChannel ssc = ServerSocketChannel.open(); Selector sel = Selector.open(); ssc.configureBlocking(false); ssc.socket().bind(new InetSocketAddress(8080)); SelectionKey key = ssc.register(sel, SelectionKey.OP_ACCEPT); while(true) { sel.select(); Iterator it = sel.selectedKeys().iterator(); while(it.hasNext()) { SelectionKey skey = (SelectionKey)it.next(); it.remove(); if(skey.isAcceptable()) { ch = ssc.accept(); } } }这段代码只会接受连过来的连接，不做任何操作，仅仅用来测试待机连接数极限。
大家可以看到这段代码是 NIO 的基本写法，没什么特别的。
Netty 实现百万连接NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoopGroup workerGroup= new NioEventLoopGroup(); ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup); bootstrap.channel( NioServerSocketChannel.class); bootstrap.childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo: add handler }}); bootstrap.bind(8080).sync();这段其实也是非常简单的 Netty 初始化代码。同样，为了实现百万连接根本没有什么特殊的地方。
瓶颈到底在哪
上面两种不同的实现都非常简单，没有任何难度，那有人肯定会问了：实现百万连接的瓶颈到底是什么？
其实只要 java 中用的是非阻塞 IO（NIO 和 AIO 都算），那么它们都可以用单线程来实现大量的 Socket 连接。 不会像 BIO 那样为每个连接创建一个线程，因为代码层面不会成为瓶颈。
其实真正的瓶颈是在 Linux 内核配置上，默认的配置会限制全局最大打开文件数(Max Open Files)还会限制进程数。 所以需要对 Linux 内核配置进行一定的修改才可以。
这个东西现在看似很简单，按照网上的配置改一下就行了，但是大家一定不知道第一个研究这个人有多难。
这里直接贴几篇文章，介绍了相关配置的修改方式：
构建C1000K的服务器
100万并发连接服务器笔记之1M并发连接目标达成
淘宝技术分享 HTTP长连接200万尝试及调优
如何验证
让服务器支持百万连接一点也不难，我们当时很快就搞定了一个测试服务端，但是最大的问题是，我怎么去验证这个服务器可以支撑百万连接呢？
我们用 Netty 写了一个测试客户端，它同样用了非阻塞 IO ，所以不用开大量的线程。 但是一台机器上的端口数是有限制的，用root权限的话，最多也就 6W 多个连接了。 所以我们这里用 Netty 写一个客户端，用尽单机所有的连接吧。NioEventLoopGroup workerGroup = new NioEventLoopGroup(); Bootstrap b = new Bootstrap(); b.group(workerGroup); b.channel( NioSocketChannel.class); b.handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo:add handler } }); for (int k = 0; k < 60000; k++) { //请自行修改成服务端的IP b.connect(127.0.0.1, 8080); }代码同样很简单，只要连上就行了，不需要做任何其他的操作。
这样只要找到一台电脑启动这个程序即可。这里需要注意一点，客户端最好和服务端一样，修改一下 Linux 内核参数配置。
怎么去找那么多机器
按照上面的做法，单机最多可以有 6W 的连接，百万连接起码需要17台机器！
如何才能突破这个限制呢？其实这个限制来自于网卡。 我们后来通过使用虚拟机，并且把虚拟机的虚拟网卡配置成了桥接模式解决了问题。
根据物理机内存大小，单个物理机起码可以跑4-5个虚拟机，所以最终百万连接只要4台物理机就够了。
讨巧的做法
除了用虚拟机充分压榨机器资源外，还有一个非常讨巧的做法，这个做法也是我在验证过程中偶然发现的。
根据 TCP/IP 协议，任何一方发送FIN后就会启动正常的断开流程。而如果遇到网络瞬断的情况，连接并不会自动断开。
那我们是不是可以这样做？
启动服务端，千万别设置 Socket 的keep-alive属性，默认是不设置的
用虚拟机连接服务器
强制关闭虚拟机
修改虚拟机网卡的 MAC 地址，重新启动并连接服务器
服务端接受新的连接，并保持之前的连接不断
我们要验证的是服务端的极限，所以只要一直让服务端认为有那么多连接就行了，不是吗？
经过我们的试验后，这种方法和用真实的机器连接服务端的表现是一样的，因为服务端只是认为对方网络不好罢了，不会将你断开。
另外，禁用keep-alive是因为如果不禁用，Socket 连接会自动探测连接是否可用，如果不可用会强制断开。
更高的 QPS
由于 NIO 和 Netty 都是非阻塞 IO，所以无论有多少连接，都只需要少量的线程即可。而且 QPS 不会因为连接数的增长而降低（在内存足够的前提下）。
而且 Netty 本身设计得足够好了，Netty 不是高 QPS 的瓶颈。那高 QPS 的瓶颈是什么？
是数据结构的设计！
如何优化数据结构
首先要熟悉各种数据结构的特点是必需的，但是在复杂的项目中，不是用了一个集合就可以搞定的，有时候往往是各种集合的组合使用。
既要做到高性能，还要做到一致性，还不能有死锁，这里难度真的不小…
我在这里总结的经验是，不要过早优化。优先考虑一致性，保证数据的准确，然后再去想办法优化性能。
因为一致性比性能重要得多，而且很多性能问题在量小和量大的时候，瓶颈完全会在不同的地方。 所以，我觉得最佳的做法是，编写过程中以一致性为主，性能为辅；代码完成后再去找那个 TOP1，然后去解决它！
解决 CPU 瓶颈
在做这个优化前，先在测试环境中去狠狠地压你的服务器，量小量大，天壤之别。
有了压力测试后，就需要用工具来发现性能瓶颈了！
我喜欢用的是 VisualVM，打开工具后看抽样器(Sample)，根据自用时间(Self Time (CPU))倒序，排名第一的就是你需要去优化的点了！
备注：Sample 和 Profiler 有什么区别？前者是抽样，数据不是最准但是不影响性能；后者是统计准确，但是非常影响性能。 如果你的程序非常耗 CPU，那么尽量用 Sample，否则开启 Profiler 后降低性能，反而会影响准确性。
还记得我们项目第一次发现的瓶颈竟然是ConcurrentLinkedQueue这个类中的size()方法。 量小的时候没有影响，但是Queue很大的时候，它每次都是从头统计总数的，而这个size()方法我们又是非常频繁地调用的，所以对性能产生了影响。
size()的实现如下：public int size() { int count = 0; for (Node<E> p = first(); p != null; p = succ(p)) if (p.item != null) // Collection.size() spec says to max out if (++count == Integer.MAX_VALUE) break; return count; }后来我们通过额外使用一个AtomicInteger来计数，解决了问题。但是分离后岂不是做不到高一致性呢？ 没关系，我们的这部分代码关心最终一致性，所以只要保证最终一致就可以了。
总之，具体案例要具体分析，不同的业务要用不同的实现。
解决 GC 瓶颈
GC 瓶颈也是 CPU 瓶颈的一部分，因为不合理的 GC 会大大影响 CPU 性能。
这里还是在用 VisualVM，但是你需要装一个插件：VisualGC
有了这个插件后，你就可以直观的看到 GC 活动情况了。
按照我们的理解，在压测的时候，有大量的 New GC 是很正常的，因为有大量的对象在创建和销毁。
但是一开始有很多 Old GC 就有点说不过去了！
后来发现，在我们压测环境中，因为 Netty 的 QPS 和连接数关联不大，所以我们只连接了少量的连接。内存分配得也不是很多。
而 JVM 中，默认的新生代和老生代的比例是1:2，所以大量的老生代被浪费了，新生代不够用。
通过调整 -XX:NewRatio 后，Old GC 有了显著的降低。
但是，生产环境又不一样了，生产环境不会有那么大的 QPS，但是连接会很多，连接相关的对象存活时间非常长，所以生产环境更应该分配更多的老生代。
总之，GC 优化和 CPU 优化一样，也需要不断调整，不断优化，不是一蹴而就的。
其他优化
如果你已经完成了自己的程序，那么一定要看看《Netty in Action》作者的这个网站：Netty Best Practices a.k.a Faster == Better。
相信你会受益匪浅，经过里面提到的一些小小的优化后，我们的整体 QPS 提升了很多。
最后一点就是，java 1.7 比 java 1.6 性能高很多！因为 Netty 的编写风格是事件机制的，看似是 AIO。 可 java 1.6 是没有 AIO 的，java 1.7 是支持 AIO 的，所以如果用 java 1.7 的话，性能也会有显著提升。
最后成果
经过几周的不断压测和不断优化了，我们在一台16核、120G内存(JVM只分配8G)的机器上，用 java 1.6 达到了60万的连接和20万的QPS。
其实这还不是极限，JVM 只分配了8G内存，内存配置再大一点连接数还可以上去；
QPS 看似很高，System Load Average 很低，也就是说明瓶颈不在 CPU 也不在内存，那么应该是在 IO 了！ 上面的 Linux 配置是为了达到百万连接而配置的，并没有针对我们自己的业务场景去做优化。
因为目前性能完全够用，线上单机 QPS 最多才 1W，所以我们先把精力放在了其他地方。 相信后面我们还会去继续优化这块的性能，期待 QPS 能有更大的突破！
本作品由 Dozer 创作，采用 知识共享署名-非商业性使用 4.0 国际许可协议 进行许可。 查看全部
推送服务
还记得一年半前，做的一个项目需要用到 Android 推送服务。和 iOS 不同，Android 生态中没有统一的推送服务。Google 虽然有 Google Cloud Messaging ，但是连国外都没统一，更别说国内了，直接被墙。
所以之前在 Android 上做推送大部分只能靠轮询。而我们之前在技术调研的时候，搜到了 jPush 的博客，上面介绍了一些他们的技术特点，他们主要做的其实就是移动网络下的长连接服务。单机 50W-100W 的连接的确是吓我一跳！后来我们也采用了他们的免费方案，因为是一个受众面很小的产品，所以他们的免费版够我们用了。一年多下来，运作稳定，非常不错！
时隔两年，换了部门后，竟然接到了一项任务，优化公司自己的长连接服务端。
再次搜索网上技术资料后才发现，相关的很多难点都被攻破，网上也有了很多的总结文章，单机 50W-100W 的连接完全不是梦，其实人人都可以做到。但是光有连接还不够，QPS 也要一起上去。
所以，这篇文章就是汇总一下利用 Netty 实现长连接服务过程中的各种难点和可优化点。
Netty 是什么
Netty: http://netty.io/
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.
官方的解释最精准了，期中最吸引人的就是高性能了。但是很多人会有这样的疑问：直接用 NIO 实现的话，一定会更快吧？就像我直接手写 JDBC 虽然代码量大了点，但是一定比 iBatis 快！
但是，如果了解 Netty 后你才会发现，这个还真不一定！
利用 Netty 而不用 NIO 直接写的优势有这些：
高性能高扩展的架构设计，大部分情况下你只需要关注业务而不需要关注架构
Zero-Copy 技术尽量减少内存拷贝
为 Linux 实现 Native 版 Socket
写同一份代码，兼容 java 1.7 的 NIO2 和 1.7 之前版本的 NIO
Pooled Buffers 大大减轻 Buffer 和释放 Buffer 的压力
……
特性太多，大家可以去看一下《Netty in Action》这本书了解更多。
另外，Netty 源码是一本很好的教科书！大家在使用的过程中可以多看看它的源码，非常棒！
瓶颈是什么
想要做一个长链服务的话，最终的目标是什么？而它的瓶颈又是什么？
其实目标主要就两个：
更多的连接
更高的 QPS
所以，下面就针对这连个目标来说说他们的难点和注意点吧。
更多的连接
非阻塞 IO
其实无论是用 Java NIO 还是用 Netty，达到百万连接都没有任何难度。因为它们都是非阻塞的 IO，不需要为每个连接创建一个线程了。
欲知详情，可以搜索一下BIO,NIO,AIO的相关知识点。
Java NIO 实现百万连接ServerSocketChannel ssc = ServerSocketChannel.open(); Selector sel = Selector.open(); ssc.configureBlocking(false); ssc.socket().bind(new InetSocketAddress(8080)); SelectionKey key = ssc.register(sel, SelectionKey.OP_ACCEPT); while(true) { sel.select(); Iterator it = sel.selectedKeys().iterator(); while(it.hasNext()) { SelectionKey skey = (SelectionKey)it.next(); it.remove(); if(skey.isAcceptable()) { ch = ssc.accept(); } } }这段代码只会接受连过来的连接，不做任何操作，仅仅用来测试待机连接数极限。
大家可以看到这段代码是 NIO 的基本写法，没什么特别的。
Netty 实现百万连接NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoopGroup workerGroup= new NioEventLoopGroup(); ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup); bootstrap.channel( NioServerSocketChannel.class); bootstrap.childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo: add handler }}); bootstrap.bind(8080).sync();这段其实也是非常简单的 Netty 初始化代码。同样，为了实现百万连接根本没有什么特殊的地方。
瓶颈到底在哪
上面两种不同的实现都非常简单，没有任何难度，那有人肯定会问了：实现百万连接的瓶颈到底是什么？
其实只要 java 中用的是非阻塞 IO（NIO 和 AIO 都算），那么它们都可以用单线程来实现大量的 Socket 连接。 不会像 BIO 那样为每个连接创建一个线程，因为代码层面不会成为瓶颈。
其实真正的瓶颈是在 Linux 内核配置上，默认的配置会限制全局最大打开文件数(Max Open Files)还会限制进程数。 所以需要对 Linux 内核配置进行一定的修改才可以。
这个东西现在看似很简单，按照网上的配置改一下就行了，但是大家一定不知道第一个研究这个人有多难。
这里直接贴几篇文章，介绍了相关配置的修改方式：
构建C1000K的服务器
100万并发连接服务器笔记之1M并发连接目标达成
淘宝技术分享 HTTP长连接200万尝试及调优
如何验证
让服务器支持百万连接一点也不难，我们当时很快就搞定了一个测试服务端，但是最大的问题是，我怎么去验证这个服务器可以支撑百万连接呢？
我们用 Netty 写了一个测试客户端，它同样用了非阻塞 IO ，所以不用开大量的线程。 但是一台机器上的端口数是有限制的，用root权限的话，最多也就 6W 多个连接了。 所以我们这里用 Netty 写一个客户端，用尽单机所有的连接吧。NioEventLoopGroup workerGroup = new NioEventLoopGroup(); Bootstrap b = new Bootstrap(); b.group(workerGroup); b.channel( NioSocketChannel.class); b.handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo:add handler } }); for (int k = 0; k < 60000; k++) { //请自行修改成服务端的IP b.connect(127.0.0.1, 8080); }代码同样很简单，只要连上就行了，不需要做任何其他的操作。
这样只要找到一台电脑启动这个程序即可。这里需要注意一点，客户端最好和服务端一样，修改一下 Linux 内核参数配置。
怎么去找那么多机器
按照上面的做法，单机最多可以有 6W 的连接，百万连接起码需要17台机器！
如何才能突破这个限制呢？其实这个限制来自于网卡。 我们后来通过使用虚拟机，并且把虚拟机的虚拟网卡配置成了桥接模式解决了问题。
根据物理机内存大小，单个物理机起码可以跑4-5个虚拟机，所以最终百万连接只要4台物理机就够了。
讨巧的做法
除了用虚拟机充分压榨机器资源外，还有一个非常讨巧的做法，这个做法也是我在验证过程中偶然发现的。
根据 TCP/IP 协议，任何一方发送FIN后就会启动正常的断开流程。而如果遇到网络瞬断的情况，连接并不会自动断开。
那我们是不是可以这样做？
启动服务端，千万别设置 Socket 的keep-alive属性，默认是不设置的
用虚拟机连接服务器
强制关闭虚拟机
修改虚拟机网卡的 MAC 地址，重新启动并连接服务器
服务端接受新的连接，并保持之前的连接不断
我们要验证的是服务端的极限，所以只要一直让服务端认为有那么多连接就行了，不是吗？
经过我们的试验后，这种方法和用真实的机器连接服务端的表现是一样的，因为服务端只是认为对方网络不好罢了，不会将你断开。
另外，禁用keep-alive是因为如果不禁用，Socket 连接会自动探测连接是否可用，如果不可用会强制断开。
更高的 QPS
由于 NIO 和 Netty 都是非阻塞 IO，所以无论有多少连接，都只需要少量的线程即可。而且 QPS 不会因为连接数的增长而降低（在内存足够的前提下）。
而且 Netty 本身设计得足够好了，Netty 不是高 QPS 的瓶颈。那高 QPS 的瓶颈是什么？
是数据结构的设计！
如何优化数据结构
首先要熟悉各种数据结构的特点是必需的，但是在复杂的项目中，不是用了一个集合就可以搞定的，有时候往往是各种集合的组合使用。
既要做到高性能，还要做到一致性，还不能有死锁，这里难度真的不小…
我在这里总结的经验是，不要过早优化。优先考虑一致性，保证数据的准确，然后再去想办法优化性能。
因为一致性比性能重要得多，而且很多性能问题在量小和量大的时候，瓶颈完全会在不同的地方。 所以，我觉得最佳的做法是，编写过程中以一致性为主，性能为辅；代码完成后再去找那个 TOP1，然后去解决它！
解决 CPU 瓶颈
在做这个优化前，先在测试环境中去狠狠地压你的服务器，量小量大，天壤之别。
有了压力测试后，就需要用工具来发现性能瓶颈了！
我喜欢用的是 VisualVM，打开工具后看抽样器(Sample)，根据自用时间(Self Time (CPU))倒序，排名第一的就是你需要去优化的点了！
备注：Sample 和 Profiler 有什么区别？前者是抽样，数据不是最准但是不影响性能；后者是统计准确，但是非常影响性能。 如果你的程序非常耗 CPU，那么尽量用 Sample，否则开启 Profiler 后降低性能，反而会影响准确性。
还记得我们项目第一次发现的瓶颈竟然是ConcurrentLinkedQueue这个类中的size()方法。 量小的时候没有影响，但是Queue很大的时候，它每次都是从头统计总数的，而这个size()方法我们又是非常频繁地调用的，所以对性能产生了影响。
size()的实现如下：public int size() { int count = 0; for (Node<E> p = first(); p != null; p = succ(p)) if (p.item != null) // Collection.size() spec says to max out if (++count == Integer.MAX_VALUE) break; return count; }后来我们通过额外使用一个AtomicInteger来计数，解决了问题。但是分离后岂不是做不到高一致性呢？ 没关系，我们的这部分代码关心最终一致性，所以只要保证最终一致就可以了。
总之，具体案例要具体分析，不同的业务要用不同的实现。
解决 GC 瓶颈
GC 瓶颈也是 CPU 瓶颈的一部分，因为不合理的 GC 会大大影响 CPU 性能。
这里还是在用 VisualVM，但是你需要装一个插件：VisualGC
有了这个插件后，你就可以直观的看到 GC 活动情况了。
按照我们的理解，在压测的时候，有大量的 New GC 是很正常的，因为有大量的对象在创建和销毁。
但是一开始有很多 Old GC 就有点说不过去了！
后来发现，在我们压测环境中，因为 Netty 的 QPS 和连接数关联不大，所以我们只连接了少量的连接。内存分配得也不是很多。
而 JVM 中，默认的新生代和老生代的比例是1:2，所以大量的老生代被浪费了，新生代不够用。
通过调整 -XX:NewRatio 后，Old GC 有了显著的降低。
但是，生产环境又不一样了，生产环境不会有那么大的 QPS，但是连接会很多，连接相关的对象存活时间非常长，所以生产环境更应该分配更多的老生代。
总之，GC 优化和 CPU 优化一样，也需要不断调整，不断优化，不是一蹴而就的。
其他优化
如果你已经完成了自己的程序，那么一定要看看《Netty in Action》作者的这个网站：Netty Best Practices a.k.a Faster == Better。
相信你会受益匪浅，经过里面提到的一些小小的优化后，我们的整体 QPS 提升了很多。
最后一点就是，java 1.7 比 java 1.6 性能高很多！因为 Netty 的编写风格是事件机制的，看似是 AIO。 可 java 1.6 是没有 AIO 的，java 1.7 是支持 AIO 的，所以如果用 java 1.7 的话，性能也会有显著提升。
最后成果
经过几周的不断压测和不断优化了，我们在一台16核、120G内存(JVM只分配8G)的机器上，用 java 1.6 达到了60万的连接和20万的QPS。
其实这还不是极限，JVM 只分配了8G内存，内存配置再大一点连接数还可以上去；
QPS 看似很高，System Load Average 很低，也就是说明瓶颈不在 CPU 也不在内存，那么应该是在 IO 了！ 上面的 Linux 配置是为了达到百万连接而配置的，并没有针对我们自己的业务场景去做优化。
因为目前性能完全够用，线上单机 QPS 最多才 1W，所以我们先把精力放在了其他地方。 相信后面我们还会去继续优化这块的性能，期待 QPS 能有更大的突破！
本作品由 Dozer 创作，采用 知识共享署名-非商业性使用 4.0 国际许可协议 进行许可。
还记得一年半前，做的一个项目需要用到 Android 推送服务。和 iOS 不同，Android 生态中没有统一的推送服务。Google 虽然有 Google Cloud Messaging ，但是连国外都没统一，更别说国内了，直接被墙。
所以之前在 Android 上做推送大部分只能靠轮询。而我们之前在技术调研的时候，搜到了 jPush 的博客，上面介绍了一些他们的技术特点，他们主要做的其实就是移动网络下的长连接服务。单机 50W-100W 的连接的确是吓我一跳！后来我们也采用了他们的免费方案，因为是一个受众面很小的产品，所以他们的免费版够我们用了。一年多下来，运作稳定，非常不错！
时隔两年，换了部门后，竟然接到了一项任务，优化公司自己的长连接服务端。
再次搜索网上技术资料后才发现，相关的很多难点都被攻破，网上也有了很多的总结文章，单机 50W-100W 的连接完全不是梦，其实人人都可以做到。但是光有连接还不够，QPS 也要一起上去。
所以，这篇文章就是汇总一下利用 Netty 实现长连接服务过程中的各种难点和可优化点。
Netty 是什么
Netty: http://netty.io/
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.
官方的解释最精准了，期中最吸引人的就是高性能了。但是很多人会有这样的疑问：直接用 NIO 实现的话，一定会更快吧？就像我直接手写 JDBC 虽然代码量大了点，但是一定比 iBatis 快！
但是，如果了解 Netty 后你才会发现，这个还真不一定！
利用 Netty 而不用 NIO 直接写的优势有这些：
高性能高扩展的架构设计，大部分情况下你只需要关注业务而不需要关注架构
Zero-Copy 技术尽量减少内存拷贝
为 Linux 实现 Native 版 Socket
写同一份代码，兼容 java 1.7 的 NIO2 和 1.7 之前版本的 NIO
Pooled Buffers 大大减轻 Buffer 和释放 Buffer 的压力
……
特性太多，大家可以去看一下《Netty in Action》这本书了解更多。
另外，Netty 源码是一本很好的教科书！大家在使用的过程中可以多看看它的源码，非常棒！
瓶颈是什么
想要做一个长链服务的话，最终的目标是什么？而它的瓶颈又是什么？
其实目标主要就两个：
更多的连接
更高的 QPS
所以，下面就针对这连个目标来说说他们的难点和注意点吧。
更多的连接
非阻塞 IO
其实无论是用 Java NIO 还是用 Netty，达到百万连接都没有任何难度。因为它们都是非阻塞的 IO，不需要为每个连接创建一个线程了。
欲知详情，可以搜索一下BIO,NIO,AIO的相关知识点。
Java NIO 实现百万连接ServerSocketChannel ssc = ServerSocketChannel.open(); Selector sel = Selector.open(); ssc.configureBlocking(false); ssc.socket().bind(new InetSocketAddress(8080)); SelectionKey key = ssc.register(sel, SelectionKey.OP_ACCEPT); while(true) { sel.select(); Iterator it = sel.selectedKeys().iterator(); while(it.hasNext()) { SelectionKey skey = (SelectionKey)it.next(); it.remove(); if(skey.isAcceptable()) { ch = ssc.accept(); } } }这段代码只会接受连过来的连接，不做任何操作，仅仅用来测试待机连接数极限。
大家可以看到这段代码是 NIO 的基本写法，没什么特别的。
Netty 实现百万连接NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoopGroup workerGroup= new NioEventLoopGroup(); ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup); bootstrap.channel( NioServerSocketChannel.class); bootstrap.childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo: add handler }}); bootstrap.bind(8080).sync();这段其实也是非常简单的 Netty 初始化代码。同样，为了实现百万连接根本没有什么特殊的地方。
瓶颈到底在哪
上面两种不同的实现都非常简单，没有任何难度，那有人肯定会问了：实现百万连接的瓶颈到底是什么？
其实只要 java 中用的是非阻塞 IO（NIO 和 AIO 都算），那么它们都可以用单线程来实现大量的 Socket 连接。 不会像 BIO 那样为每个连接创建一个线程，因为代码层面不会成为瓶颈。
其实真正的瓶颈是在 Linux 内核配置上，默认的配置会限制全局最大打开文件数(Max Open Files)还会限制进程数。 所以需要对 Linux 内核配置进行一定的修改才可以。
这个东西现在看似很简单，按照网上的配置改一下就行了，但是大家一定不知道第一个研究这个人有多难。
这里直接贴几篇文章，介绍了相关配置的修改方式：
构建C1000K的服务器
100万并发连接服务器笔记之1M并发连接目标达成
淘宝技术分享 HTTP长连接200万尝试及调优
如何验证
让服务器支持百万连接一点也不难，我们当时很快就搞定了一个测试服务端，但是最大的问题是，我怎么去验证这个服务器可以支撑百万连接呢？
我们用 Netty 写了一个测试客户端，它同样用了非阻塞 IO ，所以不用开大量的线程。 但是一台机器上的端口数是有限制的，用root权限的话，最多也就 6W 多个连接了。 所以我们这里用 Netty 写一个客户端，用尽单机所有的连接吧。NioEventLoopGroup workerGroup = new NioEventLoopGroup(); Bootstrap b = new Bootstrap(); b.group(workerGroup); b.channel( NioSocketChannel.class); b.handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); //todo:add handler } }); for (int k = 0; k < 60000; k++) { //请自行修改成服务端的IP b.connect(127.0.0.1, 8080); }代码同样很简单，只要连上就行了，不需要做任何其他的操作。
这样只要找到一台电脑启动这个程序即可。这里需要注意一点，客户端最好和服务端一样，修改一下 Linux 内核参数配置。
怎么去找那么多机器
按照上面的做法，单机最多可以有 6W 的连接，百万连接起码需要17台机器！
如何才能突破这个限制呢？其实这个限制来自于网卡。 我们后来通过使用虚拟机，并且把虚拟机的虚拟网卡配置成了桥接模式解决了问题。
根据物理机内存大小，单个物理机起码可以跑4-5个虚拟机，所以最终百万连接只要4台物理机就够了。
讨巧的做法
除了用虚拟机充分压榨机器资源外，还有一个非常讨巧的做法，这个做法也是我在验证过程中偶然发现的。
根据 TCP/IP 协议，任何一方发送FIN后就会启动正常的断开流程。而如果遇到网络瞬断的情况，连接并不会自动断开。
那我们是不是可以这样做？
启动服务端，千万别设置 Socket 的keep-alive属性，默认是不设置的
用虚拟机连接服务器
强制关闭虚拟机
修改虚拟机网卡的 MAC 地址，重新启动并连接服务器
服务端接受新的连接，并保持之前的连接不断
我们要验证的是服务端的极限，所以只要一直让服务端认为有那么多连接就行了，不是吗？
经过我们的试验后，这种方法和用真实的机器连接服务端的表现是一样的，因为服务端只是认为对方网络不好罢了，不会将你断开。
另外，禁用keep-alive是因为如果不禁用，Socket 连接会自动探测连接是否可用，如果不可用会强制断开。
更高的 QPS
由于 NIO 和 Netty 都是非阻塞 IO，所以无论有多少连接，都只需要少量的线程即可。而且 QPS 不会因为连接数的增长而降低（在内存足够的前提下）。
而且 Netty 本身设计得足够好了，Netty 不是高 QPS 的瓶颈。那高 QPS 的瓶颈是什么？
是数据结构的设计！
如何优化数据结构
首先要熟悉各种数据结构的特点是必需的，但是在复杂的项目中，不是用了一个集合就可以搞定的，有时候往往是各种集合的组合使用。
既要做到高性能，还要做到一致性，还不能有死锁，这里难度真的不小…
我在这里总结的经验是，不要过早优化。优先考虑一致性，保证数据的准确，然后再去想办法优化性能。
因为一致性比性能重要得多，而且很多性能问题在量小和量大的时候，瓶颈完全会在不同的地方。 所以，我觉得最佳的做法是，编写过程中以一致性为主，性能为辅；代码完成后再去找那个 TOP1，然后去解决它！
解决 CPU 瓶颈
在做这个优化前，先在测试环境中去狠狠地压你的服务器，量小量大，天壤之别。
有了压力测试后，就需要用工具来发现性能瓶颈了！
我喜欢用的是 VisualVM，打开工具后看抽样器(Sample)，根据自用时间(Self Time (CPU))倒序，排名第一的就是你需要去优化的点了！
备注：Sample 和 Profiler 有什么区别？前者是抽样，数据不是最准但是不影响性能；后者是统计准确，但是非常影响性能。 如果你的程序非常耗 CPU，那么尽量用 Sample，否则开启 Profiler 后降低性能，反而会影响准确性。
还记得我们项目第一次发现的瓶颈竟然是ConcurrentLinkedQueue这个类中的size()方法。 量小的时候没有影响，但是Queue很大的时候，它每次都是从头统计总数的，而这个size()方法我们又是非常频繁地调用的，所以对性能产生了影响。
size()的实现如下：public int size() { int count = 0; for (Node<E> p = first(); p != null; p = succ(p)) if (p.item != null) // Collection.size() spec says to max out if (++count == Integer.MAX_VALUE) break; return count; }后来我们通过额外使用一个AtomicInteger来计数，解决了问题。但是分离后岂不是做不到高一致性呢？ 没关系，我们的这部分代码关心最终一致性，所以只要保证最终一致就可以了。
总之，具体案例要具体分析，不同的业务要用不同的实现。
解决 GC 瓶颈
GC 瓶颈也是 CPU 瓶颈的一部分，因为不合理的 GC 会大大影响 CPU 性能。
这里还是在用 VisualVM，但是你需要装一个插件：VisualGC
有了这个插件后，你就可以直观的看到 GC 活动情况了。
按照我们的理解，在压测的时候，有大量的 New GC 是很正常的，因为有大量的对象在创建和销毁。
但是一开始有很多 Old GC 就有点说不过去了！
后来发现，在我们压测环境中，因为 Netty 的 QPS 和连接数关联不大，所以我们只连接了少量的连接。内存分配得也不是很多。
而 JVM 中，默认的新生代和老生代的比例是1:2，所以大量的老生代被浪费了，新生代不够用。
通过调整 -XX:NewRatio 后，Old GC 有了显著的降低。
但是，生产环境又不一样了，生产环境不会有那么大的 QPS，但是连接会很多，连接相关的对象存活时间非常长，所以生产环境更应该分配更多的老生代。
总之，GC 优化和 CPU 优化一样，也需要不断调整，不断优化，不是一蹴而就的。
其他优化
如果你已经完成了自己的程序，那么一定要看看《Netty in Action》作者的这个网站：Netty Best Practices a.k.a Faster == Better。
相信你会受益匪浅，经过里面提到的一些小小的优化后，我们的整体 QPS 提升了很多。
最后一点就是，java 1.7 比 java 1.6 性能高很多！因为 Netty 的编写风格是事件机制的，看似是 AIO。 可 java 1.6 是没有 AIO 的，java 1.7 是支持 AIO 的，所以如果用 java 1.7 的话，性能也会有显著提升。
最后成果
经过几周的不断压测和不断优化了，我们在一台16核、120G内存(JVM只分配8G)的机器上，用 java 1.6 达到了60万的连接和20万的QPS。
其实这还不是极限，JVM 只分配了8G内存，内存配置再大一点连接数还可以上去；
QPS 看似很高，System Load Average 很低，也就是说明瓶颈不在 CPU 也不在内存，那么应该是在 IO 了！ 上面的 Linux 配置是为了达到百万连接而配置的，并没有针对我们自己的业务场景去做优化。
因为目前性能完全够用，线上单机 QPS 最多才 1W，所以我们先把精力放在了其他地方。 相信后面我们还会去继续优化这块的性能，期待 QPS 能有更大的突破！
本作品由 Dozer 创作，采用 知识共享署名-非商业性使用 4.0 国际许可协议 进行许可。
0
评论
如何构建分布式SFU/MCU媒体服务器？
beyond 发表了文章 • 448 次浏览 • 2019-11-26 14:40
本文来自英特尔实时通信解决方案架构师 段先德在LiveVideoStackCon2019上海大会的分享，详细介绍了英特尔在进行分布式SFU/MCU媒体服务器的架构设计中秉持的一些设计原则以及关键问题的解决思路。
大家好，我是来自英特尔上海研发中心的段先德。从2014年开始主要做基于WebRTC的实时通信和统一通信解决方案。对于实时通讯来说WebRTC技术是一个革命性的存在。2014年4月英特尔发布了Intel® Collaboration Suite for WebRTC，这是一款可免费使用的包含服务器侧程序和客户端SDK的完整解决方案。经过多年的迭代更新，当前最新发布的是4.2版本。
1. Requirements and Design Principles
本次分享的内容主要分为三个部分，首先介绍英特尔ICS for WebRTC项目中要解决的问题；其次介绍我们在解决这些问题的时候的指导思想和整体设计原则；最后介绍我们的解决方案目前的状态以及当下和近期要做的一些事情。
1.1 Functional Requirements
我们项目团队最初的出发点是希望能做一套够达到一般功能性要求的基于互联网的视频会议解决方案。譬如可以支持WebRTC和SIP终端，实现接入到同一个会议中。SIP主要针对的是存量设备，重点是对WebRTC终端的支持。WebRTC接入相比于很多以前存量的企业视频会议解决方案有很多的突破，从2011年以后Chrome在端多媒体系统，弱网对抗方面以及音视频处理这方面一直在持续的改进。
英特尔很早就注意到在WebRTC时代，亟需一个统一的终端和服务器侧的解决方案。我们需要把企业内外的一些移动终端、桌面应用、浏览器、传统的SIP终端设备都支持起来，需要支持NAT穿越和屏幕共享，需要支持服务器侧音视频录制，等等。这里面很多功能性需求通过传统SIP的解决方案做起来很不方便或者成本很高，但是在WebRTC时代，在基于互联网应用的技术思路下，可以很便捷、很优雅地解决这些问题，于是我们在2014年做了ICS for WebRTC v1.0。之后在2016年和2017年之间直播类的应用大爆发使得有些客户希望我们的解决方案里面能够支持直播类场景，把实时互动场景下的音视频流通过RTMP/RTSP/HLS/Dash推送到现有的CDN网络里面去。基于这类需求，我们在功能性方面增加了互动Streaming的能力。
2018年到现在，直播的用户体验要求越来越高，客户希望主播和粉丝或者观众之间的互动能够非常平滑的切换，同时端到端的时延也能够做得更好，也就是希望做到保证端到端的实时性的前提下，在单个呼叫里支持海量的用户连接。这就要求服务器侧系统既要有非常大的“扇出”能力，要支持终端连接在“发布者”和“订阅者”之间非常平滑地进行切换。我们目前正在做的就是把目前的解决方案扩展到这种能够支持大规模并发的“实时互动广播”，初步目标是单个呼叫里达到百万以上的并发连接，而且端到端的时延能够全球控制在300毫秒以内。关于端到端时延，我们在国内互联网上做过一些小规模的测试，测试结果的时延是150毫秒以内。我们还希望这个解决方案能够很方便封装成类似于CDN的服务访问接口或者形式，以便集成到客户现有的直播解决方案中去。
我们当前的解决方案已经具备了非常灵活的服务器侧媒体处理，服务器端可以做音视频的混音混流，比如说当前的一个呼叫里面有十几个参与方，有的参与方希望订阅呼叫中其他参与方发布的原始流，有的参与方希望订阅所有或部分参与方的mix流，有的参与方希望订阅符合自己对codec、分辨率、帧率、码率等定制化要求的转发流，我们当前的解决方案已经可以很好地支持这些需求。
1.2 Nonfunctional Requirements
如果仅仅是为了达到前面所讲的各种功能性需求，随便选择一个现有的开源框架去改改，再自己从头写一些功能模块拼凑一下，总可以整出一个PoC的版本或可以初步走向产品的东西。如果是要严肃地做一个打算把它放到生产环境去运营的产品级别的东西，真正考验这个解决方案的生命力的其实是它在非功能性需求方面的取舍和功力。即使是选择现有的开源框架去做产品，这个框架对非功能性方面的考量也是最重要的决定因素。
在非功能性方面主要关注的点有三个方面。
一是系统的可扩展性，它的服务部署规模可大可小，可以小到在一台英特尔®️ 酷睿™️i7的PC上部署使用，大到一个集群几百台甚至上千台机器组成一个大的cluster上部署使用。另外呼叫的参与方式可以是两三个人的讨论会，或者十几个人一般视频会议，又或者是几十人的在线课堂。部署时可以在当前的系统容量不足时在不中断业务的前提下增加或者删减当前部署的规模，达到很灵活的Scale in/Scale out。
二是容错性，容错能力大多描述都比较抽象，但是落实到系统在做设计的时候要考虑的东西就是非常具体的设计决策，在系统设计里面我们会强调甚至固执的坚持每一个部件都可能会出错，运行时都会发生crash，这就需要在流程设计或者一般逻辑里面handle这些问题，在系统发生部分失效的时候，要能够做到自动恢复或服务优雅降级。
三是分布式部署，单台机器上单实例的部署是不可能做容错的，只有分布式的部署才能够做到。我们要求允许把任何部件部署在数据中心的多台机器上面。我们现在进一步的要求是要能够把任何部件部署在多个数据中心，进行跨数据中心的分布式部署。
2.Unified Media Spread Model UMSM）
2.1 Modularization at Runtime
要满足上述的各种功能性和非功能性需求，就需要在概念模型上对系统的各个部件进行足够的抽象，将逻辑上独立的部件封装到运行时独立的模块里面——即模块化。不管是从单一职责的角度来说，还是从系统的可组合性来说，模块化是自始至终不能打破的一个原则，是我们当前系统——也是很多复杂系统进行架构的第一原则。在我们的系统设计中，对于跟客户端交互的部件来说，要把信令和媒体分开。对于媒体部分来说，媒体的接入部分和处理部分一定是分开的，直接和用户打交道的部分和后台内部的一些处理部件，不管是从单一职责角度来讲还是从面向接口的健壮性要求来讲都必须把它们分开。
我们的服务器侧系统在运行时可以分成五大块。
第一块就是跟客户端进行信令交互的部件，即图中的WebRTC Portal和SIP Portal。他们跟WebRTC客户端和SIP终端进行信令交互。值得注意的一点是WebRTC标准对信令交互的格式和通道没有规定，我们采用的是一种承载在socket.io通道中的私有协议。
第二块是跟客户端进行音视频媒体交互的部件，即图中的WebRTC Agent、Streaming Agent、SIP Agent和Recording Agent。其中WebRTC Agent负责跟客户端之间建立PeerConnection连接，SIP Agent跟SIP终端RTP流进行传输，Streaming Agent是针对RTSP/RTMP/HLS/Dash流，我们可以把IPCamera的RTSP流作为输入直接拉到系统里面来，也可以把系统里面任何一个输入流/合成流/转码后的流作为输出推送到RTMP Server上去，Recording虽然是完全发生在服务器侧的行为，但实际上在概念层次上面是更接近于流的输出。所以在概念模型里我们也把Recording Agent当做媒体接出部件，以达到概念模型的一致性。
第三块是媒体处理的部件，即图中的Audio Agent和Video Agent。Audio Agent是进行音频混音转码工作的部件，Video Agent是视频的合屏和转码的部件，这些所有的部件都是单独部署独立进程在运行。
第四块是呼叫控制的部件，即图中的Conference Agent。我们的系统还是将多方实时音视频通信作为场景基础，Conference Agent就是一通呼叫的总控制部件，它负责room中的参与者、流、订阅关系的控制和管理。对于像远程教育、远程医疗、远程协助之类的其他场景，我们主要是通过对Conference Agent来进行拓展和增强去支持。
第五块就是一些支持部件。整个服务器系统在运行和单机运行时都是cluster形式，Cluster Manager就是一个简单的cluster管理器。视频会议场景中会有一些room的预配置和管理，room的配置数据存放在MongoDB中，管理员都是通过OAM UI通过RESTful API访问Management API部件实现数据访问并受理REST请求。另外各个部件之间的rpc是架设在RabbitMQ消息队列上的。
2.2 Strong Isolation
第二个原则就是要做强隔离。在系统里面坚持执行的原则就是要做强隔离，运行时一定是把看到的逻辑上面独立部件，把它在物理上也做成完全独立的运行时进程。比如像信令受理部件和信令执行部件就是分别独立的进程。这样做使得信令受理部件可以独立于呼叫控制里面的业务逻辑而存在。同理媒体接入部件和媒体处理部件也是分别独立进程。这里的进程就是OS语义上面进程，是我们服务器侧系统构建的基本元素，是生命体的细胞，不同的部件之间进行通讯唯一的方式就是message passing（消息传递）。在概念模型里面看的得到部件都是用单独的Worker进程来处理一个独立的Job。比方说一个Video Agent生成出来的Video Node，它的职责要么是做一个视频混流器，要么是做一个视频转码器，单独运行，独立工作。这样做一方面是进行错误隔离一个部件中产生的异常不会传染影响其他部件，一方面是各个运行时部件可以进行运行时单独进行升级替换。
2.3 Hierarchy in Media Accessing/Processing
第三个原则就是层次化。具体体现在在媒体接入和媒体处理的一些部件的设计和实现上，这些部件在南北（纵）向上面有明确的层次划分，自下而上分为包交互层、帧交互层和内容操作层。以媒体接入部件为例，我们服务器侧系统需要跟各种外围系统和终端进行媒体交互，有的媒体是通过RTP/SRTP包的形式输入、输出，有的媒体是直接以AVStream的行书输出、输出。当媒体进入到我们服务器侧系统内部以后，我们希望有一个统一的格式让它在所有的媒体相关部件之间自由流转，所以我们就定义了统一的MediaFrame格式，所有输入的媒体在媒体接入部件上被组装成MediaFrame。处理MediaFrame的逻辑我们把它放在帧交互层，与客户端进行RTP/SRTP交互的逻辑我们放在包交互层。另外，MediaFrame进入媒体处理部件后，如果涉及到raw格式的操作——譬如合屏、色彩调整、添加水印、替换背景等——我们就把相关逻辑放在内容操作层。
2.4 Media Pipeline in WebRTC Node
设计原则讲起来太枯燥，举两个例子。
第一个是WebRTC Node中的Pipeline结构。在WebRTCNode上面有一个明确的一个界限，广为人知的一些开源的框架里面有一些SFU框架是直接做RTP包的高级转发，而在我们的解决方案里于所有的外部媒体进入到系统里面会先将它们整理成统一的媒体（帧集的封装）之后在各个结点之间进行传输。除了使得层次分明便于系统横向扩展以外，另外一大好处就是把RTP传输相关的事务都终结在媒体接入部件（节点）上，RTP传输中的丢包、乱序等问题的处理不会扩散到系统其它部件。
2.5 Media Pipeline in Video Node (Video Mixer)
第二个例子是视频混流器内部的Pipeline结构。视频混流的部件在Pipeline上面进出都是视频帧，图上紫颜色的模块进出的都是视频已编码的帧，在视频处理部件的内部可以是一些已编码的帧，也可以是一些Scaler和Convertor。使得各个层次的处理器接口非常清楚，便于做成plugable。
2.6 Unified Media Spread Model (UMSM)
前面我们根据系统的功能性和非功能性需求，把系统拆成了一个个松散的部件。那么，怎么把这些部件捏合到一起成为一个有机的系统呢？特别是针对各个媒体接入部件和媒体处理部件之间的媒体交互，我们需要定义一个统一的内部媒体交互模型——我们称之为UMSM。
音视频媒体在系统内部流动，我们采用的是一个“发布-订阅”结构的流基本拓扑。如图所示，系统有一个发布者发布一个流进入到系统里，此时有两个订阅者，其中一个订阅者希望订阅发布的原始流的直接转发流，另外一个订阅者希望订阅房间里面所有的原始流合成流合屏以后的mix流，流的发布者和订阅者的PeerConnection连接建立在不同的WebRTC Node上面，通过PeerConnection进入WebRTC Node的SRTP包流，经过解密，被整理封装成MediaFrame（Audioframe/Videoframe），之后再在不同的部件之间进行传递，如果有订阅者需要的是直接转发流，就把它封装好的音频和视频的帧直接扩散到订阅者所连接的WebRTC Node上面来，如果有订阅者需要合成的流（合屏和混音的流），那么就把混流和混音以后的MediaFrame从AudioNode（Audio Mixer）和VideoNode（Video Mixer）扩散到订阅者所连接的WebRTC Node上。
有了这样一个足够松散的系统内部流扩散结构，无论这些媒体接入部件和媒体处理部件是运行在同一台机器上还是运行在一个数据中心内的不同机器上——甚至运行在位于不同数据中心的不同机器上，都有统一的、一致的流拓扑结构。
2.7 Media Spread Protocol
要实现这样一个流扩散模型，重点要解决两个方面的问题，一个是媒体节点间的传输，另一个是媒体节点的控制。
媒体节点间的传输是面向连接的，因为扩散链路都可能持续比较长的时间，且一般服务器侧部件的部署环境的网络条件是可控的，有利于保障传输质量。另外每一个连接结点间的扩散链路的连接是双向的，因为有可能两个媒体流的接入结点之间存在双向的扩散，以及与媒体流相关的一些feedback信息需要被反向传递，我们希望它能够复用在同一个扩散链路上面。另外我们需要它是可靠的，在以前跟合作伙伴做技术交流的时候他们对于要求流扩散链路必须是可靠的这一点有疑惑。实际上这是一个实时性和可靠性的取舍问题，我们选择在这个环节保证可靠性，而把实时性推给底层去解决，因为如果要在流扩散链路的所有环节处理信号损失，将给上层逻辑带来巨大的复杂性。
2.8 MSP - Transport Control Primitives(WIP)
传输控制就是对于节点间扩散传输链路的控制，目前为了方便在采用的是TCP，在同一数据中心内进行流扩散问题不大，在应用到跨数据中心的部署场景中时，特别是tts和delay比较大的情况下，实际可用的throughput会受比较大的影响，目前仍有一些改进的工作还在进行当中，我们也在调研SCTP和QUIC。
2.9 MSP - Underlying Transport Protocols(TCP vs.QUIC under weak network)
我们在节点间扩散时加一些网损的情况下用TCP和QUIC有做过一些对比测试。QUIC和TCP都是可靠传输，在有网损的时候都会产生一些重传或者是冗余，但是他们不同的拥塞控制策略会对端到端的媒体传递的质量产生不同的影响。我们的对比测试中，发送端是以恒定的码率和帧率（24fps）向服务器侧发送视频流，服务器侧在节点间分别采用TCP和QUIC进行节点间媒体流扩散，图中截取的是相同的网损条件下接收端收到的实际帧率，在5%的丢包和30ms delay时， TCP的帧率就会抖动的非常厉害，在接收端体验就会看到点不流畅，能明显地看到它的卡顿。当加上10%的丢包时波动就跟家剧烈，有时甚至降低到0fps，接收端的用户体验就是非常明的卡顿。相比而言，在QUIC上面还能够看到，接收端的帧率能够更好地坚持在24fps上下，接收端的流畅度更好。总体来看，QUIC是在弱网环境下进行节点间流扩散的一个不错的备选传输。
2.10 MSP - Media Control Primitives
媒体控制的操作对于媒体节点来说，一个publish就是往媒体结点上面发布一路流，给它增加一个input，一个subscribe就是在它上面去增添一个output，linkup就是把一个input和output接续起来，cutoff就把一个input和一个output拆开。对于媒体处理的结点有一些内生的流，generate就是让它产生一路流指定规格（codec、分辨率、帧率、码率、关键帧间隔等），degenerate就是让它取消正在生成中的一个流。
3.Cross DC Media Spread
3.1 Cross DC Media Spread:Relay Node (WIP)
做TCP和QUIC的对比调研目的就是解决跨数据中心通过Internet进行节点间媒体流扩散的实时性（本质是throughput）问题。由于在跨数据中心媒体扩散的时候需要在Internet上面做流扩散，Internet在传输质量上讲没有在数据中心里的效果那么满意，需要找一些基于UDP改进的可靠传输协议去尝试，我们调研过SCTP和QUIC，总体来看QUIC的表现是相当不错的。
同时为了减少同一条流在两个数据中心的多个节点间传输，我们增加了一个Relay Agent（Node）的部件，使得同一条流在两个数据中心之间只需要扩散一次。Relay Agent的另一个作用是进行流扩散的时候的路由控制，譬如一个集团公司的很多分支机房并不是BGP的，需要将流汇聚到指定的BGP机房才能更好地向其他地区数据中心扩散。
3.2 Access Node(Agent) Scheduling
在部署了多个接入节点以后，除了通过增加接入节点来扩充系统的scalability，我们还希望能够利用接入节点的不同地理位置给靠近它的终端用户做就近接入。以WebRTC Agent为例，在部署WebRTC Agent的时候可以指定它的capacity（能力），capacity上面有两个标签，一个是isp，一个是region。用户在进行通信连接请求的时候，它带上isp和region的preference（喜好），系统在进行WebRTC Agent调度的时候会对所有可用的WebRTC Agent的capacity与用户指定的preference进行匹配，找到最满意的接入结点，最后达到就近接入的目的。
在符合preference的候选不止一个时，系统还提供基于work load和历史使用记录进行last-used、least-used、round-robin、random等调度策略，选取符合指定策略的接入节点。
3.3 CDN alike Service
解决了跨数据中心部署的媒体流扩散和调度问题后，我们的解决方案就可以提供更广阔的实时多方音视频通信服务。特别是有了Relay Agent的级联能力后，我们服务器侧系统就可以得到极大的提升，譬如假设单个媒体接入节点的扇出能力是1:1000的话，经过一级级联后就能达到1:100万，经过两级级联后就能达到1:10亿，已经堪比一般CDN的扇出能力了。而CDN的就是本质是一个分布式的cache系统，cache是实时应用的天敌。许多既要求海量扇出比，又要求实时性，并且要随时平滑进行流拓扑切换的场景下，CDN就显得无能为力了，而我们的解决方案将覆盖这些场景，特别是在5G和IoT的时代。
原文发布于微信公众号 - LiveVideoStack（livevideostack） 查看全部
大家好，我是来自英特尔上海研发中心的段先德。从2014年开始主要做基于WebRTC的实时通信和统一通信解决方案。对于实时通讯来说WebRTC技术是一个革命性的存在。2014年4月英特尔发布了Intel® Collaboration Suite for WebRTC，这是一款可免费使用的包含服务器侧程序和客户端SDK的完整解决方案。经过多年的迭代更新，当前最新发布的是4.2版本。
1. Requirements and Design Principles
本次分享的内容主要分为三个部分，首先介绍英特尔ICS for WebRTC项目中要解决的问题；其次介绍我们在解决这些问题的时候的指导思想和整体设计原则；最后介绍我们的解决方案目前的状态以及当下和近期要做的一些事情。
1.1 Functional Requirements
我们项目团队最初的出发点是希望能做一套够达到一般功能性要求的基于互联网的视频会议解决方案。譬如可以支持WebRTC和SIP终端，实现接入到同一个会议中。SIP主要针对的是存量设备，重点是对WebRTC终端的支持。WebRTC接入相比于很多以前存量的企业视频会议解决方案有很多的突破，从2011年以后Chrome在端多媒体系统，弱网对抗方面以及音视频处理这方面一直在持续的改进。
英特尔很早就注意到在WebRTC时代，亟需一个统一的终端和服务器侧的解决方案。我们需要把企业内外的一些移动终端、桌面应用、浏览器、传统的SIP终端设备都支持起来，需要支持NAT穿越和屏幕共享，需要支持服务器侧音视频录制，等等。这里面很多功能性需求通过传统SIP的解决方案做起来很不方便或者成本很高，但是在WebRTC时代，在基于互联网应用的技术思路下，可以很便捷、很优雅地解决这些问题，于是我们在2014年做了ICS for WebRTC v1.0。之后在2016年和2017年之间直播类的应用大爆发使得有些客户希望我们的解决方案里面能够支持直播类场景，把实时互动场景下的音视频流通过RTMP/RTSP/HLS/Dash推送到现有的CDN网络里面去。基于这类需求，我们在功能性方面增加了互动Streaming的能力。
2018年到现在，直播的用户体验要求越来越高，客户希望主播和粉丝或者观众之间的互动能够非常平滑的切换，同时端到端的时延也能够做得更好，也就是希望做到保证端到端的实时性的前提下，在单个呼叫里支持海量的用户连接。这就要求服务器侧系统既要有非常大的“扇出”能力，要支持终端连接在“发布者”和“订阅者”之间非常平滑地进行切换。我们目前正在做的就是把目前的解决方案扩展到这种能够支持大规模并发的“实时互动广播”，初步目标是单个呼叫里达到百万以上的并发连接，而且端到端的时延能够全球控制在300毫秒以内。关于端到端时延，我们在国内互联网上做过一些小规模的测试，测试结果的时延是150毫秒以内。我们还希望这个解决方案能够很方便封装成类似于CDN的服务访问接口或者形式，以便集成到客户现有的直播解决方案中去。
我们当前的解决方案已经具备了非常灵活的服务器侧媒体处理，服务器端可以做音视频的混音混流，比如说当前的一个呼叫里面有十几个参与方，有的参与方希望订阅呼叫中其他参与方发布的原始流，有的参与方希望订阅所有或部分参与方的mix流，有的参与方希望订阅符合自己对codec、分辨率、帧率、码率等定制化要求的转发流，我们当前的解决方案已经可以很好地支持这些需求。
1.2 Nonfunctional Requirements
如果仅仅是为了达到前面所讲的各种功能性需求，随便选择一个现有的开源框架去改改，再自己从头写一些功能模块拼凑一下，总可以整出一个PoC的版本或可以初步走向产品的东西。如果是要严肃地做一个打算把它放到生产环境去运营的产品级别的东西，真正考验这个解决方案的生命力的其实是它在非功能性需求方面的取舍和功力。即使是选择现有的开源框架去做产品，这个框架对非功能性方面的考量也是最重要的决定因素。
在非功能性方面主要关注的点有三个方面。
一是系统的可扩展性，它的服务部署规模可大可小，可以小到在一台英特尔®️ 酷睿™️i7的PC上部署使用，大到一个集群几百台甚至上千台机器组成一个大的cluster上部署使用。另外呼叫的参与方式可以是两三个人的讨论会，或者十几个人一般视频会议，又或者是几十人的在线课堂。部署时可以在当前的系统容量不足时在不中断业务的前提下增加或者删减当前部署的规模，达到很灵活的Scale in/Scale out。
二是容错性，容错能力大多描述都比较抽象，但是落实到系统在做设计的时候要考虑的东西就是非常具体的设计决策，在系统设计里面我们会强调甚至固执的坚持每一个部件都可能会出错，运行时都会发生crash，这就需要在流程设计或者一般逻辑里面handle这些问题，在系统发生部分失效的时候，要能够做到自动恢复或服务优雅降级。
三是分布式部署，单台机器上单实例的部署是不可能做容错的，只有分布式的部署才能够做到。我们要求允许把任何部件部署在数据中心的多台机器上面。我们现在进一步的要求是要能够把任何部件部署在多个数据中心，进行跨数据中心的分布式部署。
2.Unified Media Spread Model UMSM）
2.1 Modularization at Runtime
要满足上述的各种功能性和非功能性需求，就需要在概念模型上对系统的各个部件进行足够的抽象，将逻辑上独立的部件封装到运行时独立的模块里面——即模块化。不管是从单一职责的角度来说，还是从系统的可组合性来说，模块化是自始至终不能打破的一个原则，是我们当前系统——也是很多复杂系统进行架构的第一原则。在我们的系统设计中，对于跟客户端交互的部件来说，要把信令和媒体分开。对于媒体部分来说，媒体的接入部分和处理部分一定是分开的，直接和用户打交道的部分和后台内部的一些处理部件，不管是从单一职责角度来讲还是从面向接口的健壮性要求来讲都必须把它们分开。
我们的服务器侧系统在运行时可以分成五大块。
第一块就是跟客户端进行信令交互的部件，即图中的WebRTC Portal和SIP Portal。他们跟WebRTC客户端和SIP终端进行信令交互。值得注意的一点是WebRTC标准对信令交互的格式和通道没有规定，我们采用的是一种承载在socket.io通道中的私有协议。
第二块是跟客户端进行音视频媒体交互的部件，即图中的WebRTC Agent、Streaming Agent、SIP Agent和Recording Agent。其中WebRTC Agent负责跟客户端之间建立PeerConnection连接，SIP Agent跟SIP终端RTP流进行传输，Streaming Agent是针对RTSP/RTMP/HLS/Dash流，我们可以把IPCamera的RTSP流作为输入直接拉到系统里面来，也可以把系统里面任何一个输入流/合成流/转码后的流作为输出推送到RTMP Server上去，Recording虽然是完全发生在服务器侧的行为，但实际上在概念层次上面是更接近于流的输出。所以在概念模型里我们也把Recording Agent当做媒体接出部件，以达到概念模型的一致性。
第三块是媒体处理的部件，即图中的Audio Agent和Video Agent。Audio Agent是进行音频混音转码工作的部件，Video Agent是视频的合屏和转码的部件，这些所有的部件都是单独部署独立进程在运行。
第四块是呼叫控制的部件，即图中的Conference Agent。我们的系统还是将多方实时音视频通信作为场景基础，Conference Agent就是一通呼叫的总控制部件，它负责room中的参与者、流、订阅关系的控制和管理。对于像远程教育、远程医疗、远程协助之类的其他场景，我们主要是通过对Conference Agent来进行拓展和增强去支持。
第五块就是一些支持部件。整个服务器系统在运行和单机运行时都是cluster形式，Cluster Manager就是一个简单的cluster管理器。视频会议场景中会有一些room的预配置和管理，room的配置数据存放在MongoDB中，管理员都是通过OAM UI通过RESTful API访问Management API部件实现数据访问并受理REST请求。另外各个部件之间的rpc是架设在RabbitMQ消息队列上的。
2.2 Strong Isolation
第二个原则就是要做强隔离。在系统里面坚持执行的原则就是要做强隔离，运行时一定是把看到的逻辑上面独立部件，把它在物理上也做成完全独立的运行时进程。比如像信令受理部件和信令执行部件就是分别独立的进程。这样做使得信令受理部件可以独立于呼叫控制里面的业务逻辑而存在。同理媒体接入部件和媒体处理部件也是分别独立进程。这里的进程就是OS语义上面进程，是我们服务器侧系统构建的基本元素，是生命体的细胞，不同的部件之间进行通讯唯一的方式就是message passing（消息传递）。在概念模型里面看的得到部件都是用单独的Worker进程来处理一个独立的Job。比方说一个Video Agent生成出来的Video Node，它的职责要么是做一个视频混流器，要么是做一个视频转码器，单独运行，独立工作。这样做一方面是进行错误隔离一个部件中产生的异常不会传染影响其他部件，一方面是各个运行时部件可以进行运行时单独进行升级替换。
2.3 Hierarchy in Media Accessing/Processing
第三个原则就是层次化。具体体现在在媒体接入和媒体处理的一些部件的设计和实现上，这些部件在南北（纵）向上面有明确的层次划分，自下而上分为包交互层、帧交互层和内容操作层。以媒体接入部件为例，我们服务器侧系统需要跟各种外围系统和终端进行媒体交互，有的媒体是通过RTP/SRTP包的形式输入、输出，有的媒体是直接以AVStream的行书输出、输出。当媒体进入到我们服务器侧系统内部以后，我们希望有一个统一的格式让它在所有的媒体相关部件之间自由流转，所以我们就定义了统一的MediaFrame格式，所有输入的媒体在媒体接入部件上被组装成MediaFrame。处理MediaFrame的逻辑我们把它放在帧交互层，与客户端进行RTP/SRTP交互的逻辑我们放在包交互层。另外，MediaFrame进入媒体处理部件后，如果涉及到raw格式的操作——譬如合屏、色彩调整、添加水印、替换背景等——我们就把相关逻辑放在内容操作层。
2.4 Media Pipeline in WebRTC Node
设计原则讲起来太枯燥，举两个例子。
第一个是WebRTC Node中的Pipeline结构。在WebRTCNode上面有一个明确的一个界限，广为人知的一些开源的框架里面有一些SFU框架是直接做RTP包的高级转发，而在我们的解决方案里于所有的外部媒体进入到系统里面会先将它们整理成统一的媒体（帧集的封装）之后在各个结点之间进行传输。除了使得层次分明便于系统横向扩展以外，另外一大好处就是把RTP传输相关的事务都终结在媒体接入部件（节点）上，RTP传输中的丢包、乱序等问题的处理不会扩散到系统其它部件。
2.5 Media Pipeline in Video Node (Video Mixer)
第二个例子是视频混流器内部的Pipeline结构。视频混流的部件在Pipeline上面进出都是视频帧，图上紫颜色的模块进出的都是视频已编码的帧，在视频处理部件的内部可以是一些已编码的帧，也可以是一些Scaler和Convertor。使得各个层次的处理器接口非常清楚，便于做成plugable。
2.6 Unified Media Spread Model (UMSM)
前面我们根据系统的功能性和非功能性需求，把系统拆成了一个个松散的部件。那么，怎么把这些部件捏合到一起成为一个有机的系统呢？特别是针对各个媒体接入部件和媒体处理部件之间的媒体交互，我们需要定义一个统一的内部媒体交互模型——我们称之为UMSM。
音视频媒体在系统内部流动，我们采用的是一个“发布-订阅”结构的流基本拓扑。如图所示，系统有一个发布者发布一个流进入到系统里，此时有两个订阅者，其中一个订阅者希望订阅发布的原始流的直接转发流，另外一个订阅者希望订阅房间里面所有的原始流合成流合屏以后的mix流，流的发布者和订阅者的PeerConnection连接建立在不同的WebRTC Node上面，通过PeerConnection进入WebRTC Node的SRTP包流，经过解密，被整理封装成MediaFrame（Audioframe/Videoframe），之后再在不同的部件之间进行传递，如果有订阅者需要的是直接转发流，就把它封装好的音频和视频的帧直接扩散到订阅者所连接的WebRTC Node上面来，如果有订阅者需要合成的流（合屏和混音的流），那么就把混流和混音以后的MediaFrame从AudioNode（Audio Mixer）和VideoNode（Video Mixer）扩散到订阅者所连接的WebRTC Node上。
有了这样一个足够松散的系统内部流扩散结构，无论这些媒体接入部件和媒体处理部件是运行在同一台机器上还是运行在一个数据中心内的不同机器上——甚至运行在位于不同数据中心的不同机器上，都有统一的、一致的流拓扑结构。
2.7 Media Spread Protocol
要实现这样一个流扩散模型，重点要解决两个方面的问题，一个是媒体节点间的传输，另一个是媒体节点的控制。
媒体节点间的传输是面向连接的，因为扩散链路都可能持续比较长的时间，且一般服务器侧部件的部署环境的网络条件是可控的，有利于保障传输质量。另外每一个连接结点间的扩散链路的连接是双向的，因为有可能两个媒体流的接入结点之间存在双向的扩散，以及与媒体流相关的一些feedback信息需要被反向传递，我们希望它能够复用在同一个扩散链路上面。另外我们需要它是可靠的，在以前跟合作伙伴做技术交流的时候他们对于要求流扩散链路必须是可靠的这一点有疑惑。实际上这是一个实时性和可靠性的取舍问题，我们选择在这个环节保证可靠性，而把实时性推给底层去解决，因为如果要在流扩散链路的所有环节处理信号损失，将给上层逻辑带来巨大的复杂性。
2.8 MSP - Transport Control Primitives(WIP)
传输控制就是对于节点间扩散传输链路的控制，目前为了方便在采用的是TCP，在同一数据中心内进行流扩散问题不大，在应用到跨数据中心的部署场景中时，特别是tts和delay比较大的情况下，实际可用的throughput会受比较大的影响，目前仍有一些改进的工作还在进行当中，我们也在调研SCTP和QUIC。
2.9 MSP - Underlying Transport Protocols(TCP vs.QUIC under weak network)
我们在节点间扩散时加一些网损的情况下用TCP和QUIC有做过一些对比测试。QUIC和TCP都是可靠传输，在有网损的时候都会产生一些重传或者是冗余，但是他们不同的拥塞控制策略会对端到端的媒体传递的质量产生不同的影响。我们的对比测试中，发送端是以恒定的码率和帧率（24fps）向服务器侧发送视频流，服务器侧在节点间分别采用TCP和QUIC进行节点间媒体流扩散，图中截取的是相同的网损条件下接收端收到的实际帧率，在5%的丢包和30ms delay时， TCP的帧率就会抖动的非常厉害，在接收端体验就会看到点不流畅，能明显地看到它的卡顿。当加上10%的丢包时波动就跟家剧烈，有时甚至降低到0fps，接收端的用户体验就是非常明的卡顿。相比而言，在QUIC上面还能够看到，接收端的帧率能够更好地坚持在24fps上下，接收端的流畅度更好。总体来看，QUIC是在弱网环境下进行节点间流扩散的一个不错的备选传输。
2.10 MSP - Media Control Primitives
媒体控制的操作对于媒体节点来说，一个publish就是往媒体结点上面发布一路流，给它增加一个input，一个subscribe就是在它上面去增添一个output，linkup就是把一个input和output接续起来，cutoff就把一个input和一个output拆开。对于媒体处理的结点有一些内生的流，generate就是让它产生一路流指定规格（codec、分辨率、帧率、码率、关键帧间隔等），degenerate就是让它取消正在生成中的一个流。
3.Cross DC Media Spread
3.1 Cross DC Media Spread:Relay Node (WIP)
做TCP和QUIC的对比调研目的就是解决跨数据中心通过Internet进行节点间媒体流扩散的实时性（本质是throughput）问题。由于在跨数据中心媒体扩散的时候需要在Internet上面做流扩散，Internet在传输质量上讲没有在数据中心里的效果那么满意，需要找一些基于UDP改进的可靠传输协议去尝试，我们调研过SCTP和QUIC，总体来看QUIC的表现是相当不错的。
同时为了减少同一条流在两个数据中心的多个节点间传输，我们增加了一个Relay Agent（Node）的部件，使得同一条流在两个数据中心之间只需要扩散一次。Relay Agent的另一个作用是进行流扩散的时候的路由控制，譬如一个集团公司的很多分支机房并不是BGP的，需要将流汇聚到指定的BGP机房才能更好地向其他地区数据中心扩散。
3.2 Access Node(Agent) Scheduling
在部署了多个接入节点以后，除了通过增加接入节点来扩充系统的scalability，我们还希望能够利用接入节点的不同地理位置给靠近它的终端用户做就近接入。以WebRTC Agent为例，在部署WebRTC Agent的时候可以指定它的capacity（能力），capacity上面有两个标签，一个是isp，一个是region。用户在进行通信连接请求的时候，它带上isp和region的preference（喜好），系统在进行WebRTC Agent调度的时候会对所有可用的WebRTC Agent的capacity与用户指定的preference进行匹配，找到最满意的接入结点，最后达到就近接入的目的。
在符合preference的候选不止一个时，系统还提供基于work load和历史使用记录进行last-used、least-used、round-robin、random等调度策略，选取符合指定策略的接入节点。
3.3 CDN alike Service
解决了跨数据中心部署的媒体流扩散和调度问题后，我们的解决方案就可以提供更广阔的实时多方音视频通信服务。特别是有了Relay Agent的级联能力后，我们服务器侧系统就可以得到极大的提升，譬如假设单个媒体接入节点的扇出能力是1:1000的话，经过一级级联后就能达到1:100万，经过两级级联后就能达到1:10亿，已经堪比一般CDN的扇出能力了。而CDN的就是本质是一个分布式的cache系统，cache是实时应用的天敌。许多既要求海量扇出比，又要求实时性，并且要随时平滑进行流拓扑切换的场景下，CDN就显得无能为力了，而我们的解决方案将覆盖这些场景，特别是在5G和IoT的时代。
原文发布于微信公众号 - LiveVideoStack（livevideostack） 查看全部
本文来自英特尔实时通信解决方案架构师 段先德在LiveVideoStackCon2019上海大会的分享，详细介绍了英特尔在进行分布式SFU/MCU媒体服务器的架构设计中秉持的一些设计原则以及关键问题的解决思路。
大家好，我是来自英特尔上海研发中心的段先德。从2014年开始主要做基于WebRTC的实时通信和统一通信解决方案。对于实时通讯来说WebRTC技术是一个革命性的存在。2014年4月英特尔发布了Intel® Collaboration Suite for WebRTC，这是一款可免费使用的包含服务器侧程序和客户端SDK的完整解决方案。经过多年的迭代更新，当前最新发布的是4.2版本。
1. Requirements and Design Principles
本次分享的内容主要分为三个部分，首先介绍英特尔ICS for WebRTC项目中要解决的问题；其次介绍我们在解决这些问题的时候的指导思想和整体设计原则；最后介绍我们的解决方案目前的状态以及当下和近期要做的一些事情。
1.1 Functional Requirements
我们项目团队最初的出发点是希望能做一套够达到一般功能性要求的基于互联网的视频会议解决方案。譬如可以支持WebRTC和SIP终端，实现接入到同一个会议中。SIP主要针对的是存量设备，重点是对WebRTC终端的支持。WebRTC接入相比于很多以前存量的企业视频会议解决方案有很多的突破，从2011年以后Chrome在端多媒体系统，弱网对抗方面以及音视频处理这方面一直在持续的改进。
英特尔很早就注意到在WebRTC时代，亟需一个统一的终端和服务器侧的解决方案。我们需要把企业内外的一些移动终端、桌面应用、浏览器、传统的SIP终端设备都支持起来，需要支持NAT穿越和屏幕共享，需要支持服务器侧音视频录制，等等。这里面很多功能性需求通过传统SIP的解决方案做起来很不方便或者成本很高，但是在WebRTC时代，在基于互联网应用的技术思路下，可以很便捷、很优雅地解决这些问题，于是我们在2014年做了ICS for WebRTC v1.0。之后在2016年和2017年之间直播类的应用大爆发使得有些客户希望我们的解决方案里面能够支持直播类场景，把实时互动场景下的音视频流通过RTMP/RTSP/HLS/Dash推送到现有的CDN网络里面去。基于这类需求，我们在功能性方面增加了互动Streaming的能力。
2018年到现在，直播的用户体验要求越来越高，客户希望主播和粉丝或者观众之间的互动能够非常平滑的切换，同时端到端的时延也能够做得更好，也就是希望做到保证端到端的实时性的前提下，在单个呼叫里支持海量的用户连接。这就要求服务器侧系统既要有非常大的“扇出”能力，要支持终端连接在“发布者”和“订阅者”之间非常平滑地进行切换。我们目前正在做的就是把目前的解决方案扩展到这种能够支持大规模并发的“实时互动广播”，初步目标是单个呼叫里达到百万以上的并发连接，而且端到端的时延能够全球控制在300毫秒以内。关于端到端时延，我们在国内互联网上做过一些小规模的测试，测试结果的时延是150毫秒以内。我们还希望这个解决方案能够很方便封装成类似于CDN的服务访问接口或者形式，以便集成到客户现有的直播解决方案中去。
我们当前的解决方案已经具备了非常灵活的服务器侧媒体处理，服务器端可以做音视频的混音混流，比如说当前的一个呼叫里面有十几个参与方，有的参与方希望订阅呼叫中其他参与方发布的原始流，有的参与方希望订阅所有或部分参与方的mix流，有的参与方希望订阅符合自己对codec、分辨率、帧率、码率等定制化要求的转发流，我们当前的解决方案已经可以很好地支持这些需求。
1.2 Nonfunctional Requirements
如果仅仅是为了达到前面所讲的各种功能性需求，随便选择一个现有的开源框架去改改，再自己从头写一些功能模块拼凑一下，总可以整出一个PoC的版本或可以初步走向产品的东西。如果是要严肃地做一个打算把它放到生产环境去运营的产品级别的东西，真正考验这个解决方案的生命力的其实是它在非功能性需求方面的取舍和功力。即使是选择现有的开源框架去做产品，这个框架对非功能性方面的考量也是最重要的决定因素。
在非功能性方面主要关注的点有三个方面。
一是系统的可扩展性，它的服务部署规模可大可小，可以小到在一台英特尔®️ 酷睿™️i7的PC上部署使用，大到一个集群几百台甚至上千台机器组成一个大的cluster上部署使用。另外呼叫的参与方式可以是两三个人的讨论会，或者十几个人一般视频会议，又或者是几十人的在线课堂。部署时可以在当前的系统容量不足时在不中断业务的前提下增加或者删减当前部署的规模，达到很灵活的Scale in/Scale out。
二是容错性，容错能力大多描述都比较抽象，但是落实到系统在做设计的时候要考虑的东西就是非常具体的设计决策，在系统设计里面我们会强调甚至固执的坚持每一个部件都可能会出错，运行时都会发生crash，这就需要在流程设计或者一般逻辑里面handle这些问题，在系统发生部分失效的时候，要能够做到自动恢复或服务优雅降级。
三是分布式部署，单台机器上单实例的部署是不可能做容错的，只有分布式的部署才能够做到。我们要求允许把任何部件部署在数据中心的多台机器上面。我们现在进一步的要求是要能够把任何部件部署在多个数据中心，进行跨数据中心的分布式部署。
2.Unified Media Spread Model UMSM）
2.1 Modularization at Runtime
要满足上述的各种功能性和非功能性需求，就需要在概念模型上对系统的各个部件进行足够的抽象，将逻辑上独立的部件封装到运行时独立的模块里面——即模块化。不管是从单一职责的角度来说，还是从系统的可组合性来说，模块化是自始至终不能打破的一个原则，是我们当前系统——也是很多复杂系统进行架构的第一原则。在我们的系统设计中，对于跟客户端交互的部件来说，要把信令和媒体分开。对于媒体部分来说，媒体的接入部分和处理部分一定是分开的，直接和用户打交道的部分和后台内部的一些处理部件，不管是从单一职责角度来讲还是从面向接口的健壮性要求来讲都必须把它们分开。
我们的服务器侧系统在运行时可以分成五大块。
第一块就是跟客户端进行信令交互的部件，即图中的WebRTC Portal和SIP Portal。他们跟WebRTC客户端和SIP终端进行信令交互。值得注意的一点是WebRTC标准对信令交互的格式和通道没有规定，我们采用的是一种承载在socket.io通道中的私有协议。
第二块是跟客户端进行音视频媒体交互的部件，即图中的WebRTC Agent、Streaming Agent、SIP Agent和Recording Agent。其中WebRTC Agent负责跟客户端之间建立PeerConnection连接，SIP Agent跟SIP终端RTP流进行传输，Streaming Agent是针对RTSP/RTMP/HLS/Dash流，我们可以把IPCamera的RTSP流作为输入直接拉到系统里面来，也可以把系统里面任何一个输入流/合成流/转码后的流作为输出推送到RTMP Server上去，Recording虽然是完全发生在服务器侧的行为，但实际上在概念层次上面是更接近于流的输出。所以在概念模型里我们也把Recording Agent当做媒体接出部件，以达到概念模型的一致性。
第三块是媒体处理的部件，即图中的Audio Agent和Video Agent。Audio Agent是进行音频混音转码工作的部件，Video Agent是视频的合屏和转码的部件，这些所有的部件都是单独部署独立进程在运行。
第四块是呼叫控制的部件，即图中的Conference Agent。我们的系统还是将多方实时音视频通信作为场景基础，Conference Agent就是一通呼叫的总控制部件，它负责room中的参与者、流、订阅关系的控制和管理。对于像远程教育、远程医疗、远程协助之类的其他场景，我们主要是通过对Conference Agent来进行拓展和增强去支持。
第五块就是一些支持部件。整个服务器系统在运行和单机运行时都是cluster形式，Cluster Manager就是一个简单的cluster管理器。视频会议场景中会有一些room的预配置和管理，room的配置数据存放在MongoDB中，管理员都是通过OAM UI通过RESTful API访问Management API部件实现数据访问并受理REST请求。另外各个部件之间的rpc是架设在RabbitMQ消息队列上的。
2.2 Strong Isolation
第二个原则就是要做强隔离。在系统里面坚持执行的原则就是要做强隔离，运行时一定是把看到的逻辑上面独立部件，把它在物理上也做成完全独立的运行时进程。比如像信令受理部件和信令执行部件就是分别独立的进程。这样做使得信令受理部件可以独立于呼叫控制里面的业务逻辑而存在。同理媒体接入部件和媒体处理部件也是分别独立进程。这里的进程就是OS语义上面进程，是我们服务器侧系统构建的基本元素，是生命体的细胞，不同的部件之间进行通讯唯一的方式就是message passing（消息传递）。在概念模型里面看的得到部件都是用单独的Worker进程来处理一个独立的Job。比方说一个Video Agent生成出来的Video Node，它的职责要么是做一个视频混流器，要么是做一个视频转码器，单独运行，独立工作。这样做一方面是进行错误隔离一个部件中产生的异常不会传染影响其他部件，一方面是各个运行时部件可以进行运行时单独进行升级替换。
2.3 Hierarchy in Media Accessing/Processing
第三个原则就是层次化。具体体现在在媒体接入和媒体处理的一些部件的设计和实现上，这些部件在南北（纵）向上面有明确的层次划分，自下而上分为包交互层、帧交互层和内容操作层。以媒体接入部件为例，我们服务器侧系统需要跟各种外围系统和终端进行媒体交互，有的媒体是通过RTP/SRTP包的形式输入、输出，有的媒体是直接以AVStream的行书输出、输出。当媒体进入到我们服务器侧系统内部以后，我们希望有一个统一的格式让它在所有的媒体相关部件之间自由流转，所以我们就定义了统一的MediaFrame格式，所有输入的媒体在媒体接入部件上被组装成MediaFrame。处理MediaFrame的逻辑我们把它放在帧交互层，与客户端进行RTP/SRTP交互的逻辑我们放在包交互层。另外，MediaFrame进入媒体处理部件后，如果涉及到raw格式的操作——譬如合屏、色彩调整、添加水印、替换背景等——我们就把相关逻辑放在内容操作层。
2.4 Media Pipeline in WebRTC Node
设计原则讲起来太枯燥，举两个例子。
第一个是WebRTC Node中的Pipeline结构。在WebRTCNode上面有一个明确的一个界限，广为人知的一些开源的框架里面有一些SFU框架是直接做RTP包的高级转发，而在我们的解决方案里于所有的外部媒体进入到系统里面会先将它们整理成统一的媒体（帧集的封装）之后在各个结点之间进行传输。除了使得层次分明便于系统横向扩展以外，另外一大好处就是把RTP传输相关的事务都终结在媒体接入部件（节点）上，RTP传输中的丢包、乱序等问题的处理不会扩散到系统其它部件。
2.5 Media Pipeline in Video Node (Video Mixer)
第二个例子是视频混流器内部的Pipeline结构。视频混流的部件在Pipeline上面进出都是视频帧，图上紫颜色的模块进出的都是视频已编码的帧，在视频处理部件的内部可以是一些已编码的帧，也可以是一些Scaler和Convertor。使得各个层次的处理器接口非常清楚，便于做成plugable。
2.6 Unified Media Spread Model (UMSM)
前面我们根据系统的功能性和非功能性需求，把系统拆成了一个个松散的部件。那么，怎么把这些部件捏合到一起成为一个有机的系统呢？特别是针对各个媒体接入部件和媒体处理部件之间的媒体交互，我们需要定义一个统一的内部媒体交互模型——我们称之为UMSM。
音视频媒体在系统内部流动，我们采用的是一个“发布-订阅”结构的流基本拓扑。如图所示，系统有一个发布者发布一个流进入到系统里，此时有两个订阅者，其中一个订阅者希望订阅发布的原始流的直接转发流，另外一个订阅者希望订阅房间里面所有的原始流合成流合屏以后的mix流，流的发布者和订阅者的PeerConnection连接建立在不同的WebRTC Node上面，通过PeerConnection进入WebRTC Node的SRTP包流，经过解密，被整理封装成MediaFrame（Audioframe/Videoframe），之后再在不同的部件之间进行传递，如果有订阅者需要的是直接转发流，就把它封装好的音频和视频的帧直接扩散到订阅者所连接的WebRTC Node上面来，如果有订阅者需要合成的流（合屏和混音的流），那么就把混流和混音以后的MediaFrame从AudioNode（Audio Mixer）和VideoNode（Video Mixer）扩散到订阅者所连接的WebRTC Node上。
有了这样一个足够松散的系统内部流扩散结构，无论这些媒体接入部件和媒体处理部件是运行在同一台机器上还是运行在一个数据中心内的不同机器上——甚至运行在位于不同数据中心的不同机器上，都有统一的、一致的流拓扑结构。
2.7 Media Spread Protocol
要实现这样一个流扩散模型，重点要解决两个方面的问题，一个是媒体节点间的传输，另一个是媒体节点的控制。
媒体节点间的传输是面向连接的，因为扩散链路都可能持续比较长的时间，且一般服务器侧部件的部署环境的网络条件是可控的，有利于保障传输质量。另外每一个连接结点间的扩散链路的连接是双向的，因为有可能两个媒体流的接入结点之间存在双向的扩散，以及与媒体流相关的一些feedback信息需要被反向传递，我们希望它能够复用在同一个扩散链路上面。另外我们需要它是可靠的，在以前跟合作伙伴做技术交流的时候他们对于要求流扩散链路必须是可靠的这一点有疑惑。实际上这是一个实时性和可靠性的取舍问题，我们选择在这个环节保证可靠性，而把实时性推给底层去解决，因为如果要在流扩散链路的所有环节处理信号损失，将给上层逻辑带来巨大的复杂性。
2.8 MSP - Transport Control Primitives(WIP)
传输控制就是对于节点间扩散传输链路的控制，目前为了方便在采用的是TCP，在同一数据中心内进行流扩散问题不大，在应用到跨数据中心的部署场景中时，特别是tts和delay比较大的情况下，实际可用的throughput会受比较大的影响，目前仍有一些改进的工作还在进行当中，我们也在调研SCTP和QUIC。
2.9 MSP - Underlying Transport Protocols(TCP vs.QUIC under weak network)
我们在节点间扩散时加一些网损的情况下用TCP和QUIC有做过一些对比测试。QUIC和TCP都是可靠传输，在有网损的时候都会产生一些重传或者是冗余，但是他们不同的拥塞控制策略会对端到端的媒体传递的质量产生不同的影响。我们的对比测试中，发送端是以恒定的码率和帧率（24fps）向服务器侧发送视频流，服务器侧在节点间分别采用TCP和QUIC进行节点间媒体流扩散，图中截取的是相同的网损条件下接收端收到的实际帧率，在5%的丢包和30ms delay时， TCP的帧率就会抖动的非常厉害，在接收端体验就会看到点不流畅，能明显地看到它的卡顿。当加上10%的丢包时波动就跟家剧烈，有时甚至降低到0fps，接收端的用户体验就是非常明的卡顿。相比而言，在QUIC上面还能够看到，接收端的帧率能够更好地坚持在24fps上下，接收端的流畅度更好。总体来看，QUIC是在弱网环境下进行节点间流扩散的一个不错的备选传输。
2.10 MSP - Media Control Primitives
媒体控制的操作对于媒体节点来说，一个publish就是往媒体结点上面发布一路流，给它增加一个input，一个subscribe就是在它上面去增添一个output，linkup就是把一个input和output接续起来，cutoff就把一个input和一个output拆开。对于媒体处理的结点有一些内生的流，generate就是让它产生一路流指定规格（codec、分辨率、帧率、码率、关键帧间隔等），degenerate就是让它取消正在生成中的一个流。
3.Cross DC Media Spread
3.1 Cross DC Media Spread:Relay Node (WIP)
做TCP和QUIC的对比调研目的就是解决跨数据中心通过Internet进行节点间媒体流扩散的实时性（本质是throughput）问题。由于在跨数据中心媒体扩散的时候需要在Internet上面做流扩散，Internet在传输质量上讲没有在数据中心里的效果那么满意，需要找一些基于UDP改进的可靠传输协议去尝试，我们调研过SCTP和QUIC，总体来看QUIC的表现是相当不错的。
同时为了减少同一条流在两个数据中心的多个节点间传输，我们增加了一个Relay Agent（Node）的部件，使得同一条流在两个数据中心之间只需要扩散一次。Relay Agent的另一个作用是进行流扩散的时候的路由控制，譬如一个集团公司的很多分支机房并不是BGP的，需要将流汇聚到指定的BGP机房才能更好地向其他地区数据中心扩散。
3.2 Access Node(Agent) Scheduling
在部署了多个接入节点以后，除了通过增加接入节点来扩充系统的scalability，我们还希望能够利用接入节点的不同地理位置给靠近它的终端用户做就近接入。以WebRTC Agent为例，在部署WebRTC Agent的时候可以指定它的capacity（能力），capacity上面有两个标签，一个是isp，一个是region。用户在进行通信连接请求的时候，它带上isp和region的preference（喜好），系统在进行WebRTC Agent调度的时候会对所有可用的WebRTC Agent的capacity与用户指定的preference进行匹配，找到最满意的接入结点，最后达到就近接入的目的。
在符合preference的候选不止一个时，系统还提供基于work load和历史使用记录进行last-used、least-used、round-robin、random等调度策略，选取符合指定策略的接入节点。
3.3 CDN alike Service
解决了跨数据中心部署的媒体流扩散和调度问题后，我们的解决方案就可以提供更广阔的实时多方音视频通信服务。特别是有了Relay Agent的级联能力后，我们服务器侧系统就可以得到极大的提升，譬如假设单个媒体接入节点的扇出能力是1:1000的话，经过一级级联后就能达到1:100万，经过两级级联后就能达到1:10亿，已经堪比一般CDN的扇出能力了。而CDN的就是本质是一个分布式的cache系统，cache是实时应用的天敌。许多既要求海量扇出比，又要求实时性，并且要随时平滑进行流拓扑切换的场景下，CDN就显得无能为力了，而我们的解决方案将覆盖这些场景，特别是在5G和IoT的时代。
原文发布于微信公众号 - LiveVideoStack（livevideostack）
大家好，我是来自英特尔上海研发中心的段先德。从2014年开始主要做基于WebRTC的实时通信和统一通信解决方案。对于实时通讯来说WebRTC技术是一个革命性的存在。2014年4月英特尔发布了Intel® Collaboration Suite for WebRTC，这是一款可免费使用的包含服务器侧程序和客户端SDK的完整解决方案。经过多年的迭代更新，当前最新发布的是4.2版本。
1. Requirements and Design Principles
本次分享的内容主要分为三个部分，首先介绍英特尔ICS for WebRTC项目中要解决的问题；其次介绍我们在解决这些问题的时候的指导思想和整体设计原则；最后介绍我们的解决方案目前的状态以及当下和近期要做的一些事情。
1.1 Functional Requirements
我们项目团队最初的出发点是希望能做一套够达到一般功能性要求的基于互联网的视频会议解决方案。譬如可以支持WebRTC和SIP终端，实现接入到同一个会议中。SIP主要针对的是存量设备，重点是对WebRTC终端的支持。WebRTC接入相比于很多以前存量的企业视频会议解决方案有很多的突破，从2011年以后Chrome在端多媒体系统，弱网对抗方面以及音视频处理这方面一直在持续的改进。
英特尔很早就注意到在WebRTC时代，亟需一个统一的终端和服务器侧的解决方案。我们需要把企业内外的一些移动终端、桌面应用、浏览器、传统的SIP终端设备都支持起来，需要支持NAT穿越和屏幕共享，需要支持服务器侧音视频录制，等等。这里面很多功能性需求通过传统SIP的解决方案做起来很不方便或者成本很高，但是在WebRTC时代，在基于互联网应用的技术思路下，可以很便捷、很优雅地解决这些问题，于是我们在2014年做了ICS for WebRTC v1.0。之后在2016年和2017年之间直播类的应用大爆发使得有些客户希望我们的解决方案里面能够支持直播类场景，把实时互动场景下的音视频流通过RTMP/RTSP/HLS/Dash推送到现有的CDN网络里面去。基于这类需求，我们在功能性方面增加了互动Streaming的能力。
2018年到现在，直播的用户体验要求越来越高，客户希望主播和粉丝或者观众之间的互动能够非常平滑的切换，同时端到端的时延也能够做得更好，也就是希望做到保证端到端的实时性的前提下，在单个呼叫里支持海量的用户连接。这就要求服务器侧系统既要有非常大的“扇出”能力，要支持终端连接在“发布者”和“订阅者”之间非常平滑地进行切换。我们目前正在做的就是把目前的解决方案扩展到这种能够支持大规模并发的“实时互动广播”，初步目标是单个呼叫里达到百万以上的并发连接，而且端到端的时延能够全球控制在300毫秒以内。关于端到端时延，我们在国内互联网上做过一些小规模的测试，测试结果的时延是150毫秒以内。我们还希望这个解决方案能够很方便封装成类似于CDN的服务访问接口或者形式，以便集成到客户现有的直播解决方案中去。
我们当前的解决方案已经具备了非常灵活的服务器侧媒体处理，服务器端可以做音视频的混音混流，比如说当前的一个呼叫里面有十几个参与方，有的参与方希望订阅呼叫中其他参与方发布的原始流，有的参与方希望订阅所有或部分参与方的mix流，有的参与方希望订阅符合自己对codec、分辨率、帧率、码率等定制化要求的转发流，我们当前的解决方案已经可以很好地支持这些需求。
1.2 Nonfunctional Requirements
如果仅仅是为了达到前面所讲的各种功能性需求，随便选择一个现有的开源框架去改改，再自己从头写一些功能模块拼凑一下，总可以整出一个PoC的版本或可以初步走向产品的东西。如果是要严肃地做一个打算把它放到生产环境去运营的产品级别的东西，真正考验这个解决方案的生命力的其实是它在非功能性需求方面的取舍和功力。即使是选择现有的开源框架去做产品，这个框架对非功能性方面的考量也是最重要的决定因素。
在非功能性方面主要关注的点有三个方面。
一是系统的可扩展性，它的服务部署规模可大可小，可以小到在一台英特尔®️ 酷睿™️i7的PC上部署使用，大到一个集群几百台甚至上千台机器组成一个大的cluster上部署使用。另外呼叫的参与方式可以是两三个人的讨论会，或者十几个人一般视频会议，又或者是几十人的在线课堂。部署时可以在当前的系统容量不足时在不中断业务的前提下增加或者删减当前部署的规模，达到很灵活的Scale in/Scale out。
二是容错性，容错能力大多描述都比较抽象，但是落实到系统在做设计的时候要考虑的东西就是非常具体的设计决策，在系统设计里面我们会强调甚至固执的坚持每一个部件都可能会出错，运行时都会发生crash，这就需要在流程设计或者一般逻辑里面handle这些问题，在系统发生部分失效的时候，要能够做到自动恢复或服务优雅降级。
三是分布式部署，单台机器上单实例的部署是不可能做容错的，只有分布式的部署才能够做到。我们要求允许把任何部件部署在数据中心的多台机器上面。我们现在进一步的要求是要能够把任何部件部署在多个数据中心，进行跨数据中心的分布式部署。
2.Unified Media Spread Model UMSM）
2.1 Modularization at Runtime
要满足上述的各种功能性和非功能性需求，就需要在概念模型上对系统的各个部件进行足够的抽象，将逻辑上独立的部件封装到运行时独立的模块里面——即模块化。不管是从单一职责的角度来说，还是从系统的可组合性来说，模块化是自始至终不能打破的一个原则，是我们当前系统——也是很多复杂系统进行架构的第一原则。在我们的系统设计中，对于跟客户端交互的部件来说，要把信令和媒体分开。对于媒体部分来说，媒体的接入部分和处理部分一定是分开的，直接和用户打交道的部分和后台内部的一些处理部件，不管是从单一职责角度来讲还是从面向接口的健壮性要求来讲都必须把它们分开。
我们的服务器侧系统在运行时可以分成五大块。
第一块就是跟客户端进行信令交互的部件，即图中的WebRTC Portal和SIP Portal。他们跟WebRTC客户端和SIP终端进行信令交互。值得注意的一点是WebRTC标准对信令交互的格式和通道没有规定，我们采用的是一种承载在socket.io通道中的私有协议。
第二块是跟客户端进行音视频媒体交互的部件，即图中的WebRTC Agent、Streaming Agent、SIP Agent和Recording Agent。其中WebRTC Agent负责跟客户端之间建立PeerConnection连接，SIP Agent跟SIP终端RTP流进行传输，Streaming Agent是针对RTSP/RTMP/HLS/Dash流，我们可以把IPCamera的RTSP流作为输入直接拉到系统里面来，也可以把系统里面任何一个输入流/合成流/转码后的流作为输出推送到RTMP Server上去，Recording虽然是完全发生在服务器侧的行为，但实际上在概念层次上面是更接近于流的输出。所以在概念模型里我们也把Recording Agent当做媒体接出部件，以达到概念模型的一致性。
第三块是媒体处理的部件，即图中的Audio Agent和Video Agent。Audio Agent是进行音频混音转码工作的部件，Video Agent是视频的合屏和转码的部件，这些所有的部件都是单独部署独立进程在运行。
第四块是呼叫控制的部件，即图中的Conference Agent。我们的系统还是将多方实时音视频通信作为场景基础，Conference Agent就是一通呼叫的总控制部件，它负责room中的参与者、流、订阅关系的控制和管理。对于像远程教育、远程医疗、远程协助之类的其他场景，我们主要是通过对Conference Agent来进行拓展和增强去支持。
第五块就是一些支持部件。整个服务器系统在运行和单机运行时都是cluster形式，Cluster Manager就是一个简单的cluster管理器。视频会议场景中会有一些room的预配置和管理，room的配置数据存放在MongoDB中，管理员都是通过OAM UI通过RESTful API访问Management API部件实现数据访问并受理REST请求。另外各个部件之间的rpc是架设在RabbitMQ消息队列上的。
2.2 Strong Isolation
第二个原则就是要做强隔离。在系统里面坚持执行的原则就是要做强隔离，运行时一定是把看到的逻辑上面独立部件，把它在物理上也做成完全独立的运行时进程。比如像信令受理部件和信令执行部件就是分别独立的进程。这样做使得信令受理部件可以独立于呼叫控制里面的业务逻辑而存在。同理媒体接入部件和媒体处理部件也是分别独立进程。这里的进程就是OS语义上面进程，是我们服务器侧系统构建的基本元素，是生命体的细胞，不同的部件之间进行通讯唯一的方式就是message passing（消息传递）。在概念模型里面看的得到部件都是用单独的Worker进程来处理一个独立的Job。比方说一个Video Agent生成出来的Video Node，它的职责要么是做一个视频混流器，要么是做一个视频转码器，单独运行，独立工作。这样做一方面是进行错误隔离一个部件中产生的异常不会传染影响其他部件，一方面是各个运行时部件可以进行运行时单独进行升级替换。
2.3 Hierarchy in Media Accessing/Processing
第三个原则就是层次化。具体体现在在媒体接入和媒体处理的一些部件的设计和实现上，这些部件在南北（纵）向上面有明确的层次划分，自下而上分为包交互层、帧交互层和内容操作层。以媒体接入部件为例，我们服务器侧系统需要跟各种外围系统和终端进行媒体交互，有的媒体是通过RTP/SRTP包的形式输入、输出，有的媒体是直接以AVStream的行书输出、输出。当媒体进入到我们服务器侧系统内部以后，我们希望有一个统一的格式让它在所有的媒体相关部件之间自由流转，所以我们就定义了统一的MediaFrame格式，所有输入的媒体在媒体接入部件上被组装成MediaFrame。处理MediaFrame的逻辑我们把它放在帧交互层，与客户端进行RTP/SRTP交互的逻辑我们放在包交互层。另外，MediaFrame进入媒体处理部件后，如果涉及到raw格式的操作——譬如合屏、色彩调整、添加水印、替换背景等——我们就把相关逻辑放在内容操作层。
2.4 Media Pipeline in WebRTC Node
设计原则讲起来太枯燥，举两个例子。
第一个是WebRTC Node中的Pipeline结构。在WebRTCNode上面有一个明确的一个界限，广为人知的一些开源的框架里面有一些SFU框架是直接做RTP包的高级转发，而在我们的解决方案里于所有的外部媒体进入到系统里面会先将它们整理成统一的媒体（帧集的封装）之后在各个结点之间进行传输。除了使得层次分明便于系统横向扩展以外，另外一大好处就是把RTP传输相关的事务都终结在媒体接入部件（节点）上，RTP传输中的丢包、乱序等问题的处理不会扩散到系统其它部件。
2.5 Media Pipeline in Video Node (Video Mixer)
第二个例子是视频混流器内部的Pipeline结构。视频混流的部件在Pipeline上面进出都是视频帧，图上紫颜色的模块进出的都是视频已编码的帧，在视频处理部件的内部可以是一些已编码的帧，也可以是一些Scaler和Convertor。使得各个层次的处理器接口非常清楚，便于做成plugable。
2.6 Unified Media Spread Model (UMSM)
前面我们根据系统的功能性和非功能性需求，把系统拆成了一个个松散的部件。那么，怎么把这些部件捏合到一起成为一个有机的系统呢？特别是针对各个媒体接入部件和媒体处理部件之间的媒体交互，我们需要定义一个统一的内部媒体交互模型——我们称之为UMSM。
音视频媒体在系统内部流动，我们采用的是一个“发布-订阅”结构的流基本拓扑。如图所示，系统有一个发布者发布一个流进入到系统里，此时有两个订阅者，其中一个订阅者希望订阅发布的原始流的直接转发流，另外一个订阅者希望订阅房间里面所有的原始流合成流合屏以后的mix流，流的发布者和订阅者的PeerConnection连接建立在不同的WebRTC Node上面，通过PeerConnection进入WebRTC Node的SRTP包流，经过解密，被整理封装成MediaFrame（Audioframe/Videoframe），之后再在不同的部件之间进行传递，如果有订阅者需要的是直接转发流，就把它封装好的音频和视频的帧直接扩散到订阅者所连接的WebRTC Node上面来，如果有订阅者需要合成的流（合屏和混音的流），那么就把混流和混音以后的MediaFrame从AudioNode（Audio Mixer）和VideoNode（Video Mixer）扩散到订阅者所连接的WebRTC Node上。
有了这样一个足够松散的系统内部流扩散结构，无论这些媒体接入部件和媒体处理部件是运行在同一台机器上还是运行在一个数据中心内的不同机器上——甚至运行在位于不同数据中心的不同机器上，都有统一的、一致的流拓扑结构。
2.7 Media Spread Protocol
要实现这样一个流扩散模型，重点要解决两个方面的问题，一个是媒体节点间的传输，另一个是媒体节点的控制。
媒体节点间的传输是面向连接的，因为扩散链路都可能持续比较长的时间，且一般服务器侧部件的部署环境的网络条件是可控的，有利于保障传输质量。另外每一个连接结点间的扩散链路的连接是双向的，因为有可能两个媒体流的接入结点之间存在双向的扩散，以及与媒体流相关的一些feedback信息需要被反向传递，我们希望它能够复用在同一个扩散链路上面。另外我们需要它是可靠的，在以前跟合作伙伴做技术交流的时候他们对于要求流扩散链路必须是可靠的这一点有疑惑。实际上这是一个实时性和可靠性的取舍问题，我们选择在这个环节保证可靠性，而把实时性推给底层去解决，因为如果要在流扩散链路的所有环节处理信号损失，将给上层逻辑带来巨大的复杂性。
2.8 MSP - Transport Control Primitives(WIP)
传输控制就是对于节点间扩散传输链路的控制，目前为了方便在采用的是TCP，在同一数据中心内进行流扩散问题不大，在应用到跨数据中心的部署场景中时，特别是tts和delay比较大的情况下，实际可用的throughput会受比较大的影响，目前仍有一些改进的工作还在进行当中，我们也在调研SCTP和QUIC。
2.9 MSP - Underlying Transport Protocols(TCP vs.QUIC under weak network)
我们在节点间扩散时加一些网损的情况下用TCP和QUIC有做过一些对比测试。QUIC和TCP都是可靠传输，在有网损的时候都会产生一些重传或者是冗余，但是他们不同的拥塞控制策略会对端到端的媒体传递的质量产生不同的影响。我们的对比测试中，发送端是以恒定的码率和帧率（24fps）向服务器侧发送视频流，服务器侧在节点间分别采用TCP和QUIC进行节点间媒体流扩散，图中截取的是相同的网损条件下接收端收到的实际帧率，在5%的丢包和30ms delay时， TCP的帧率就会抖动的非常厉害，在接收端体验就会看到点不流畅，能明显地看到它的卡顿。当加上10%的丢包时波动就跟家剧烈，有时甚至降低到0fps，接收端的用户体验就是非常明的卡顿。相比而言，在QUIC上面还能够看到，接收端的帧率能够更好地坚持在24fps上下，接收端的流畅度更好。总体来看，QUIC是在弱网环境下进行节点间流扩散的一个不错的备选传输。
2.10 MSP - Media Control Primitives
媒体控制的操作对于媒体节点来说，一个publish就是往媒体结点上面发布一路流，给它增加一个input，一个subscribe就是在它上面去增添一个output，linkup就是把一个input和output接续起来，cutoff就把一个input和一个output拆开。对于媒体处理的结点有一些内生的流，generate就是让它产生一路流指定规格（codec、分辨率、帧率、码率、关键帧间隔等），degenerate就是让它取消正在生成中的一个流。
3.Cross DC Media Spread
3.1 Cross DC Media Spread:Relay Node (WIP)
做TCP和QUIC的对比调研目的就是解决跨数据中心通过Internet进行节点间媒体流扩散的实时性（本质是throughput）问题。由于在跨数据中心媒体扩散的时候需要在Internet上面做流扩散，Internet在传输质量上讲没有在数据中心里的效果那么满意，需要找一些基于UDP改进的可靠传输协议去尝试，我们调研过SCTP和QUIC，总体来看QUIC的表现是相当不错的。
同时为了减少同一条流在两个数据中心的多个节点间传输，我们增加了一个Relay Agent（Node）的部件，使得同一条流在两个数据中心之间只需要扩散一次。Relay Agent的另一个作用是进行流扩散的时候的路由控制，譬如一个集团公司的很多分支机房并不是BGP的，需要将流汇聚到指定的BGP机房才能更好地向其他地区数据中心扩散。
3.2 Access Node(Agent) Scheduling
在部署了多个接入节点以后，除了通过增加接入节点来扩充系统的scalability，我们还希望能够利用接入节点的不同地理位置给靠近它的终端用户做就近接入。以WebRTC Agent为例，在部署WebRTC Agent的时候可以指定它的capacity（能力），capacity上面有两个标签，一个是isp，一个是region。用户在进行通信连接请求的时候，它带上isp和region的preference（喜好），系统在进行WebRTC Agent调度的时候会对所有可用的WebRTC Agent的capacity与用户指定的preference进行匹配，找到最满意的接入结点，最后达到就近接入的目的。
在符合preference的候选不止一个时，系统还提供基于work load和历史使用记录进行last-used、least-used、round-robin、random等调度策略，选取符合指定策略的接入节点。
3.3 CDN alike Service
解决了跨数据中心部署的媒体流扩散和调度问题后，我们的解决方案就可以提供更广阔的实时多方音视频通信服务。特别是有了Relay Agent的级联能力后，我们服务器侧系统就可以得到极大的提升，譬如假设单个媒体接入节点的扇出能力是1:1000的话，经过一级级联后就能达到1:100万，经过两级级联后就能达到1:10亿，已经堪比一般CDN的扇出能力了。而CDN的就是本质是一个分布式的cache系统，cache是实时应用的天敌。许多既要求海量扇出比，又要求实时性，并且要随时平滑进行流拓扑切换的场景下，CDN就显得无能为力了，而我们的解决方案将覆盖这些场景，特别是在5G和IoT的时代。
原文发布于微信公众号 - LiveVideoStack（livevideostack）
0
评论
Golang实现单机百万长连接服务 - 美图的三年优化经验
beyond 发表了文章 • 373 次浏览 • 2019-11-26 11:30
美图长连接服务简介
随着科技的飞速发展，技术的日新月异，长连接的运用场景日益增多。不仅在后端服务中被广泛运用，比较常见的有数据库的访问、服务内部状态的协调等，而且在 App 端的消息推送、聊天信息、直播弹字幕等场景长连接服务也是优选方案。长连接服务的重要性也在各个场合被业界专家不断提及，与此同时也引起了更为广泛地关注和讨论，各大公司也开始构建自己的长连接服务。
美图公司于2016 年初开始构建长连接服务，与此同时， Go 在编程语言领域异军突起，考虑到其丰富的编程库，完善的工具链，简单高效的并发模型等优势，使我们最终选择 Go 去作为实现长连接服务的语言。在通信协议的选择上，考虑到 MQTT 协议的轻量、简单、易于实现的优点，选择了 MQTT 协议作为数据交互的载体。其整体的架构会在下文中做相应地介绍。
美图长连接服务（项目内部代号为bifrost ）已经历时三年，在这三年的时间里，长连接服务经过了业务的检验，同时也经历了服务的重构，存储的升级等，长连接服务从之前支持单机二十几万连接到目前可以支撑单机百万连接。在大多数长连接服务中存在一个共性问题，那就是内存占用过高，我们经常发现单个节点几十万的长连接，内存却占用十几G 甚至更多，有哪些手段能降低内存呢？
本文将从多个角度介绍长连接服务在内存优化路上的探索，首先会先通过介绍当前服务的架构模型，Go 语言的内存管理，让大家清晰地了解我们内存优化的方向和关注的重要数据。后面会重点介绍我们在内存优化上做的一些尝试以及具体的优化手段，希望对大家有一定的借鉴意义。
架构模型
一个好的架构模型设计不仅能让系统有很好的可扩展性，同时也能在服务能力上有很好的体现。除此之外，在设计上多考虑数据的抽象、模块的划分、工具链的完善，这样不仅能让软件具有更灵活的扩展能力、服务能力更高，也提高系统的稳定性和健壮性以及可维护性。
在数据抽象层面抽象pubsub 数据集合，用于消息的分发和处理。模块划分层面我们将服务一分为三：内部通讯（grpcsrv）、外部服务（mqttsrv）、连接管理（session）。工具链的方面我们构建了自动化测试，系统 mock ，压测工具。美图长连接服务架构设计如下：图一架构图从架构图中我们可以清晰地看到由7 个模块组成，分别是：conf 、grpcsrv 、mqttsrv、session、pubsub、packet、util ，每个模块的作用如下：
conf ：配置管理中心，负责服务配置的初始化，基本字段校验。
grpcsrv ：grpc 服务，集群内部信息交互协调。
mqttsrv ：mqtt 服务，接收客户端连接，同时支持单进程多端口 MQTT 服务。
session ：会话模块，管理客户端状态变化，MQTT 信息的收发。
pubsub ：发布订阅模块，按照 Topic 维度保存 session 并发布 Topic 通知给 session。
packet：协议解析模块，负责 MQTT 协议包解析。
util ：工具包，目前集成监控、日志、grpc 客户端、调度上报四个子模块。
Go 的内存管理
众所周知，Go 是一门自带垃圾回收机制的语言，内存管理参照 tcmalloc 实现，使用连续虚拟地址，以页( 8k )为单位、多级缓存进行管理。针对小于16 byte 直接使用Go的上下文P中的mcache分配，大于 32 kb 直接在 mheap 申请，剩下的先使用当前 P 的 mcache 中对应的 size class 分配 ，如果 mcache 对应的 size class 的 span 已经没有可用的块，则向 mcentral 请求。如果 mcentral 也没有可用的块，则向 mheap 申请，并切分。如果 mheap 也没有合适的 span，则向操作系统申请。
Go 在内存统计方面做的也是相当出色，提供细粒度的内存分配、GC 回收、goroutine 管理等统计数据。在优化过程中，一些数据能帮助我们发现和分析问题，在介绍优化之前，我们先来看看哪些参数需要关注，其统计参数如下：
go_memstats_sys_bytes ：进程从操作系统获得的内存的总字节数 ，其中包含 Go 运行时的堆、栈和其他内部数据结构保留的虚拟地址空间。
go_memstats_heap_inuse_bytes：在 spans 中正在使用的字节。其中不包含可能已经返回到操作系统，或者可以重用进行堆分配，或者可以将作为堆栈内存重用的字节。
go_memstats_heap_idle_bytes：在 spans 中空闲的字节。
go_memstats_stack_sys_bytes：栈内存字节，主要用于 goroutine 栈内存的分配。
在内存监控中根据Go 将堆的虚拟地址空间划分为 span ，即对内存8K或更大的连续区域进行统计。span 可能处于以下三种状态之一 ：
idle 不包含对象或其他数据，空闲空间的物理内存可以释放回 OS (但虚拟地址空间永远不会释放)，或者可以将其转换为使用中或栈空间；
inuse 至少包含一个堆对象，并且可能有空闲空间来分配更多的堆对象；
stack span 用于 goroutine 栈，栈不被认为是堆的一部分。span 可以在堆和堆栈内存之间更改，但它从来不会同时用于两者。
此外有一部分统计没有从堆内存中分配的运行时内部结构（通常因为它们是实现堆的一部分），与堆栈内存不同，分配给这些结构的任何内存都专用于这些结构，这些主要用于调试运行时内存开销。
虽然Go 拥有了丰富的标准库、语言层面支持并发、内置runtime，但相比C/C++ 完成相同逻辑的情况下 Go 消耗内存相对增多。在程序的运行过程中，它的 stack 内存会随着使用而自动扩容，但在 stack 内存回收采用惰性回收方式，一定程度的导致内存消耗增多，此外还有GC 机制也会带来额外内存的消耗。
Go 提供了三种内存回收机制：定时触发，按量触发，手动触发。在内存垃圾少量的情况下，Go 可以良好的运行。但是无论采用哪种触发方式，由于在海量用户服务的情况下造成的垃圾内存是巨大的，在 GC 执行过程中服务都会感觉明显的卡顿。这些也是目前长连接服务面对的难题，在下文中我将会逐一介绍我们如何减少和解决问题的产生的具体实践。
优化之路
在了解架构设计、Go 的内存管理、基础监控后，相信大家已经对当前系统有了一个大致的认识，先给大家展示一下内存优化的成果，下表一是内存优化前后的对比表，在线连接数基本相同的情况下，进程内存占用大幅度降低，其中 stack 申请内存降低约 5.9 G，其次 heap 使用内存降低 0.9 G，other 申请内存也小幅下降。那么我们是如何做到内存降低的呢？那接下来我将会把我们团队关于进行内存优化的探索和大家聊一聊。
在优化前随机抽取线上一台机器进行分析内存，通过监控发现当前节点进程占用虚拟内存为22.3 G，堆区使用的内存占用 5.2 G ，堆区未归还内存为 8.9 G，栈区内存为 7.25 G，其它约占用 0.9 G，连接数为 225 K。
我们简单进行换算，可以看出平均一个链接占用的内存分别为：堆：23K，栈：32K。通过对比业内长连接服务的数据可以看出单个链接占用的内存偏大，根据监控数据和内存分配原理分析主要原因在：goroutine 占用、session 状态信息、pubsub 模块占用，我们打算从业务、程序、网络模式三个方面进行优化。
业务优化
上文中提到 session 模块主要是用于处理消息的收发，在实现时考虑到在通常场景中业务的消息生产大于客户端消息的消费速度的情况，为了缓解这种状况，设计时引入消息的缓冲队列，这种做法同样也有助于做客户端消息的流控。
缓冲消息队列借助chan 实现 ，chan 大小根据经验将初始化默认配置为 128 。但在目前线上推送的场景中，我们发现，消息的生产一般小于消费的速度，128 缓冲大小明显偏大，因此我们把长度调整为 16 ，减少内存的分配。
在设计中按照topic 对客户端进行分组管理的算法中，采用空间换时间的方式，组合 map 和 list 两种数据结构对于客户端集合操作提供O（1）的删除、O（1）的添加、O（n）的遍历。数据的删除采用标记删除方式，使用辅助 slice 结构进行记录，只有到达预设阈值才会进行真正的删除。虽然标记删除提高了遍历和添加的性能，但也同样带来了内存损耗问题。
大家一定好奇什么样的场景需要提供这样的复杂度，在实际中其场景有以下两种情况：
在实际的网络场景中，客户端随时都可能由于网络的不稳定断开或者重新建联，因此集合的增加和删除需要在常数范围内。
在消息发布的流程中，采用遍历集合逐一发布通知方式，但随着单个topic 上的用户量的增加，经常会出现单个 topic 用户集合消息过热的问题，耗时太久导致消息挤压，因此针对集合的遍历当然也要求尽量快。
通过benchamrk 数据分析，在标记回收 slice 长度在 1000 时，可以提供最佳的性能，因此默认配置阈值为 1000。在线上服务中，无特殊情况都是采用默认配置。但在当前推送服务的使用中，发现标记删除和延迟回收机制好处甚微，主要是因为 topic 和客户端为 1 : 1 方式，也就是不存在客户端集合，因此调整回收阈值大小为 2，减少无效内存占用。
上述所有优化，只要简单调整配置后服务灰度上线即可，在设计实现时通过conf 模块动态配置，降低了服务的开发和维护成本。通过监控对比优化效果如下表，在优化后在线连接数比优化的在线连接更多的情况下， heap 使用内存使用数量由原来的 4.16G 下降到了 3.5G ，降低了约 0.66 G。
golang 代码优化
在实现上面展示的架构的时候发现在session 模块 和 mqttsrv 模块之间存在很多共享变量，目前实现方式都是采用指针或者值拷贝的，由于 session的数量和客户端数据量成正比也就导致消耗大量内存用于共享数据，这不仅仅增加 GC 压力，同样对于内存的消耗也是巨大的。就此问题思考再三，参考系统的库 context 的设计在架构中也抽象 context 包负责模块之间交互信息传递，统一分配内存。此外还参考他人减少临时变量的分配的优化方式，提高系统运行效率。主要优化角度参考如下：
在频繁申请内存的地方，使用pool 方式进行内存管理
小对象合并成结构体一次分配，减少内存分配次数
缓存区内容一次分配足够大小空间，并适当复用
slice 和 map 采 make 创建时，预估大小指定容量
调用栈避免申请较多的临时对象
减少[]byte 与 string 之间转换，尽量采用 []byte 来字符串处理
目前系统具被完备的单元测试、集成测试，因此经过一周的快速的开发重构后灰度上线监控数据对比如下表：在基本相同的连接数上，heap 使用内存约占用降低 0.27G，stack 申请内存占用降低 3.81G。为什么 stack 会大幅度降低呢？
通过设置stackDebug 重新编译程序追查程序运行过程，优化前 goroutine 栈的大多数在内存为 16K，通过减少临时变量的分配，拆分大函数处理逻辑，有效的减少触发栈的内存扩容（详细分析见参考文章），优化后 goroutine 栈内存降低到 8 K。一个连接需要启动两个 goroutine 负责数据的读和写，粗略计算一个连接减少约 16 K 的内存，23 w 连接约降低 3.68 G 内存。
网络模型优化
在Go 语言的网络编程中经典的实现都是采用同步处理方式，启动两个 goroutine 分别处理读和写请求，goroutine 也不像 thread ，它是轻量级的。但对于一百万连接的情况，这种设计模式至少要启动两百万的 goroutine，其中一个 goroutine 使用栈的大小在 2 KB 到 8KB， 对于资源的消耗也是极大的。在大多数场景中，只有少数连接是有数据处理，大部分 goroutine 阻塞 IO 处理中。在因此可以借鉴 C 语言的设计，在程序中使用 epoll 模型做事件分发，只有活跃连接才会启动 goroutine 处理业务，基于这种思想修改网络处理流程。
网络模型修改测试完成后开始灰度上线，通过监控数据对比如下表：在优化后比优化前的连接数多10 K的情况下，heap 使用内存降低 0.33 G，stack 申请内存降低 2.34 G，优化效果显著。
总结
在经过业务优化，临时内存优化，网络模型优化操作后，线上服务保证21w 长连接在线实际内存占用约为 5.1 G。简单进行压测 100w 连接只完成建立连接，不进行其他操作约占用 10 G。长连接服务内存优化已经取得阶段性的成功，但是这仅仅是我们团队的一小步，未来还有更多的工作要做：网络链路、服务能力，存储优化等，这些都是亟待探索的方向。如果大家有什么好的想法，欢迎与我们团队分享，共同探讨。
bifrost项目目前我们有开源计划，敬请大家期待。
参考文章
go tool pprof 使用介绍 ：https://segmentfault.com/a/1190000016412013
Go 内存监控介绍：https://golang.org/src/runtime/mstats.go
Go 内存优化介绍：https://blog.golang.org/profiling-go-programs
高性能Go服务内存分配：https://segment.com/blog/alloc ... vices
Go stack 优化分析：https://studygolang.com/article 查看全部
随着科技的飞速发展，技术的日新月异，长连接的运用场景日益增多。不仅在后端服务中被广泛运用，比较常见的有数据库的访问、服务内部状态的协调等，而且在 App 端的消息推送、聊天信息、直播弹字幕等场景长连接服务也是优选方案。长连接服务的重要性也在各个场合被业界专家不断提及，与此同时也引起了更为广泛地关注和讨论，各大公司也开始构建自己的长连接服务。
美图公司于2016 年初开始构建长连接服务，与此同时， Go 在编程语言领域异军突起，考虑到其丰富的编程库，完善的工具链，简单高效的并发模型等优势，使我们最终选择 Go 去作为实现长连接服务的语言。在通信协议的选择上，考虑到 MQTT 协议的轻量、简单、易于实现的优点，选择了 MQTT 协议作为数据交互的载体。其整体的架构会在下文中做相应地介绍。
美图长连接服务（项目内部代号为bifrost ）已经历时三年，在这三年的时间里，长连接服务经过了业务的检验，同时也经历了服务的重构，存储的升级等，长连接服务从之前支持单机二十几万连接到目前可以支撑单机百万连接。在大多数长连接服务中存在一个共性问题，那就是内存占用过高，我们经常发现单个节点几十万的长连接，内存却占用十几G 甚至更多，有哪些手段能降低内存呢？
本文将从多个角度介绍长连接服务在内存优化路上的探索，首先会先通过介绍当前服务的架构模型，Go 语言的内存管理，让大家清晰地了解我们内存优化的方向和关注的重要数据。后面会重点介绍我们在内存优化上做的一些尝试以及具体的优化手段，希望对大家有一定的借鉴意义。
架构模型
一个好的架构模型设计不仅能让系统有很好的可扩展性，同时也能在服务能力上有很好的体现。除此之外，在设计上多考虑数据的抽象、模块的划分、工具链的完善，这样不仅能让软件具有更灵活的扩展能力、服务能力更高，也提高系统的稳定性和健壮性以及可维护性。
在数据抽象层面抽象pubsub 数据集合，用于消息的分发和处理。模块划分层面我们将服务一分为三：内部通讯（grpcsrv）、外部服务（mqttsrv）、连接管理（session）。工具链的方面我们构建了自动化测试，系统 mock ，压测工具。美图长连接服务架构设计如下：图一架构图从架构图中我们可以清晰地看到由7 个模块组成，分别是：conf 、grpcsrv 、mqttsrv、session、pubsub、packet、util ，每个模块的作用如下：
conf ：配置管理中心，负责服务配置的初始化，基本字段校验。
grpcsrv ：grpc 服务，集群内部信息交互协调。
mqttsrv ：mqtt 服务，接收客户端连接，同时支持单进程多端口 MQTT 服务。
session ：会话模块，管理客户端状态变化，MQTT 信息的收发。
pubsub ：发布订阅模块，按照 Topic 维度保存 session 并发布 Topic 通知给 session。
packet：协议解析模块，负责 MQTT 协议包解析。
util ：工具包，目前集成监控、日志、grpc 客户端、调度上报四个子模块。
Go 的内存管理
众所周知，Go 是一门自带垃圾回收机制的语言，内存管理参照 tcmalloc 实现，使用连续虚拟地址，以页( 8k )为单位、多级缓存进行管理。针对小于16 byte 直接使用Go的上下文P中的mcache分配，大于 32 kb 直接在 mheap 申请，剩下的先使用当前 P 的 mcache 中对应的 size class 分配 ，如果 mcache 对应的 size class 的 span 已经没有可用的块，则向 mcentral 请求。如果 mcentral 也没有可用的块，则向 mheap 申请，并切分。如果 mheap 也没有合适的 span，则向操作系统申请。
Go 在内存统计方面做的也是相当出色，提供细粒度的内存分配、GC 回收、goroutine 管理等统计数据。在优化过程中，一些数据能帮助我们发现和分析问题，在介绍优化之前，我们先来看看哪些参数需要关注，其统计参数如下：
go_memstats_sys_bytes ：进程从操作系统获得的内存的总字节数 ，其中包含 Go 运行时的堆、栈和其他内部数据结构保留的虚拟地址空间。
go_memstats_heap_inuse_bytes：在 spans 中正在使用的字节。其中不包含可能已经返回到操作系统，或者可以重用进行堆分配，或者可以将作为堆栈内存重用的字节。
go_memstats_heap_idle_bytes：在 spans 中空闲的字节。
go_memstats_stack_sys_bytes：栈内存字节，主要用于 goroutine 栈内存的分配。
在内存监控中根据Go 将堆的虚拟地址空间划分为 span ，即对内存8K或更大的连续区域进行统计。span 可能处于以下三种状态之一 ：
idle 不包含对象或其他数据，空闲空间的物理内存可以释放回 OS (但虚拟地址空间永远不会释放)，或者可以将其转换为使用中或栈空间；
inuse 至少包含一个堆对象，并且可能有空闲空间来分配更多的堆对象；
stack span 用于 goroutine 栈，栈不被认为是堆的一部分。span 可以在堆和堆栈内存之间更改，但它从来不会同时用于两者。
此外有一部分统计没有从堆内存中分配的运行时内部结构（通常因为它们是实现堆的一部分），与堆栈内存不同，分配给这些结构的任何内存都专用于这些结构，这些主要用于调试运行时内存开销。
虽然Go 拥有了丰富的标准库、语言层面支持并发、内置runtime，但相比C/C++ 完成相同逻辑的情况下 Go 消耗内存相对增多。在程序的运行过程中，它的 stack 内存会随着使用而自动扩容，但在 stack 内存回收采用惰性回收方式，一定程度的导致内存消耗增多，此外还有GC 机制也会带来额外内存的消耗。
Go 提供了三种内存回收机制：定时触发，按量触发，手动触发。在内存垃圾少量的情况下，Go 可以良好的运行。但是无论采用哪种触发方式，由于在海量用户服务的情况下造成的垃圾内存是巨大的，在 GC 执行过程中服务都会感觉明显的卡顿。这些也是目前长连接服务面对的难题，在下文中我将会逐一介绍我们如何减少和解决问题的产生的具体实践。
优化之路
在了解架构设计、Go 的内存管理、基础监控后，相信大家已经对当前系统有了一个大致的认识，先给大家展示一下内存优化的成果，下表一是内存优化前后的对比表，在线连接数基本相同的情况下，进程内存占用大幅度降低，其中 stack 申请内存降低约 5.9 G，其次 heap 使用内存降低 0.9 G，other 申请内存也小幅下降。那么我们是如何做到内存降低的呢？那接下来我将会把我们团队关于进行内存优化的探索和大家聊一聊。
在优化前随机抽取线上一台机器进行分析内存，通过监控发现当前节点进程占用虚拟内存为22.3 G，堆区使用的内存占用 5.2 G ，堆区未归还内存为 8.9 G，栈区内存为 7.25 G，其它约占用 0.9 G，连接数为 225 K。
我们简单进行换算，可以看出平均一个链接占用的内存分别为：堆：23K，栈：32K。通过对比业内长连接服务的数据可以看出单个链接占用的内存偏大，根据监控数据和内存分配原理分析主要原因在：goroutine 占用、session 状态信息、pubsub 模块占用，我们打算从业务、程序、网络模式三个方面进行优化。
业务优化
上文中提到 session 模块主要是用于处理消息的收发，在实现时考虑到在通常场景中业务的消息生产大于客户端消息的消费速度的情况，为了缓解这种状况，设计时引入消息的缓冲队列，这种做法同样也有助于做客户端消息的流控。
缓冲消息队列借助chan 实现 ，chan 大小根据经验将初始化默认配置为 128 。但在目前线上推送的场景中，我们发现，消息的生产一般小于消费的速度，128 缓冲大小明显偏大，因此我们把长度调整为 16 ，减少内存的分配。
在设计中按照topic 对客户端进行分组管理的算法中，采用空间换时间的方式，组合 map 和 list 两种数据结构对于客户端集合操作提供O（1）的删除、O（1）的添加、O（n）的遍历。数据的删除采用标记删除方式，使用辅助 slice 结构进行记录，只有到达预设阈值才会进行真正的删除。虽然标记删除提高了遍历和添加的性能，但也同样带来了内存损耗问题。
大家一定好奇什么样的场景需要提供这样的复杂度，在实际中其场景有以下两种情况：
在实际的网络场景中，客户端随时都可能由于网络的不稳定断开或者重新建联，因此集合的增加和删除需要在常数范围内。
在消息发布的流程中，采用遍历集合逐一发布通知方式，但随着单个topic 上的用户量的增加，经常会出现单个 topic 用户集合消息过热的问题，耗时太久导致消息挤压，因此针对集合的遍历当然也要求尽量快。
通过benchamrk 数据分析，在标记回收 slice 长度在 1000 时，可以提供最佳的性能，因此默认配置阈值为 1000。在线上服务中，无特殊情况都是采用默认配置。但在当前推送服务的使用中，发现标记删除和延迟回收机制好处甚微，主要是因为 topic 和客户端为 1 : 1 方式，也就是不存在客户端集合，因此调整回收阈值大小为 2，减少无效内存占用。
上述所有优化，只要简单调整配置后服务灰度上线即可，在设计实现时通过conf 模块动态配置，降低了服务的开发和维护成本。通过监控对比优化效果如下表，在优化后在线连接数比优化的在线连接更多的情况下， heap 使用内存使用数量由原来的 4.16G 下降到了 3.5G ，降低了约 0.66 G。
golang 代码优化
在实现上面展示的架构的时候发现在session 模块 和 mqttsrv 模块之间存在很多共享变量，目前实现方式都是采用指针或者值拷贝的，由于 session的数量和客户端数据量成正比也就导致消耗大量内存用于共享数据，这不仅仅增加 GC 压力，同样对于内存的消耗也是巨大的。就此问题思考再三，参考系统的库 context 的设计在架构中也抽象 context 包负责模块之间交互信息传递，统一分配内存。此外还参考他人减少临时变量的分配的优化方式，提高系统运行效率。主要优化角度参考如下：
在频繁申请内存的地方，使用pool 方式进行内存管理
小对象合并成结构体一次分配，减少内存分配次数
缓存区内容一次分配足够大小空间，并适当复用
slice 和 map 采 make 创建时，预估大小指定容量
调用栈避免申请较多的临时对象
减少[]byte 与 string 之间转换，尽量采用 []byte 来字符串处理
目前系统具被完备的单元测试、集成测试，因此经过一周的快速的开发重构后灰度上线监控数据对比如下表：在基本相同的连接数上，heap 使用内存约占用降低 0.27G，stack 申请内存占用降低 3.81G。为什么 stack 会大幅度降低呢？
通过设置stackDebug 重新编译程序追查程序运行过程，优化前 goroutine 栈的大多数在内存为 16K，通过减少临时变量的分配，拆分大函数处理逻辑，有效的减少触发栈的内存扩容（详细分析见参考文章），优化后 goroutine 栈内存降低到 8 K。一个连接需要启动两个 goroutine 负责数据的读和写，粗略计算一个连接减少约 16 K 的内存，23 w 连接约降低 3.68 G 内存。
网络模型优化
在Go 语言的网络编程中经典的实现都是采用同步处理方式，启动两个 goroutine 分别处理读和写请求，goroutine 也不像 thread ，它是轻量级的。但对于一百万连接的情况，这种设计模式至少要启动两百万的 goroutine，其中一个 goroutine 使用栈的大小在 2 KB 到 8KB， 对于资源的消耗也是极大的。在大多数场景中，只有少数连接是有数据处理，大部分 goroutine 阻塞 IO 处理中。在因此可以借鉴 C 语言的设计，在程序中使用 epoll 模型做事件分发，只有活跃连接才会启动 goroutine 处理业务，基于这种思想修改网络处理流程。
网络模型修改测试完成后开始灰度上线，通过监控数据对比如下表：在优化后比优化前的连接数多10 K的情况下，heap 使用内存降低 0.33 G，stack 申请内存降低 2.34 G，优化效果显著。
总结
在经过业务优化，临时内存优化，网络模型优化操作后，线上服务保证21w 长连接在线实际内存占用约为 5.1 G。简单进行压测 100w 连接只完成建立连接，不进行其他操作约占用 10 G。长连接服务内存优化已经取得阶段性的成功，但是这仅仅是我们团队的一小步，未来还有更多的工作要做：网络链路、服务能力，存储优化等，这些都是亟待探索的方向。如果大家有什么好的想法，欢迎与我们团队分享，共同探讨。
bifrost项目目前我们有开源计划，敬请大家期待。
参考文章
go tool pprof 使用介绍 ：https://segmentfault.com/a/1190000016412013
Go 内存监控介绍：https://golang.org/src/runtime/mstats.go
Go 内存优化介绍：https://blog.golang.org/profiling-go-programs
高性能Go服务内存分配：https://segment.com/blog/alloc ... vices
Go stack 优化分析：https://studygolang.com/article 查看全部
美图长连接服务简介
随着科技的飞速发展，技术的日新月异，长连接的运用场景日益增多。不仅在后端服务中被广泛运用，比较常见的有数据库的访问、服务内部状态的协调等，而且在 App 端的消息推送、聊天信息、直播弹字幕等场景长连接服务也是优选方案。长连接服务的重要性也在各个场合被业界专家不断提及，与此同时也引起了更为广泛地关注和讨论，各大公司也开始构建自己的长连接服务。
美图公司于2016 年初开始构建长连接服务，与此同时， Go 在编程语言领域异军突起，考虑到其丰富的编程库，完善的工具链，简单高效的并发模型等优势，使我们最终选择 Go 去作为实现长连接服务的语言。在通信协议的选择上，考虑到 MQTT 协议的轻量、简单、易于实现的优点，选择了 MQTT 协议作为数据交互的载体。其整体的架构会在下文中做相应地介绍。
美图长连接服务（项目内部代号为bifrost ）已经历时三年，在这三年的时间里，长连接服务经过了业务的检验，同时也经历了服务的重构，存储的升级等，长连接服务从之前支持单机二十几万连接到目前可以支撑单机百万连接。在大多数长连接服务中存在一个共性问题，那就是内存占用过高，我们经常发现单个节点几十万的长连接，内存却占用十几G 甚至更多，有哪些手段能降低内存呢？
本文将从多个角度介绍长连接服务在内存优化路上的探索，首先会先通过介绍当前服务的架构模型，Go 语言的内存管理，让大家清晰地了解我们内存优化的方向和关注的重要数据。后面会重点介绍我们在内存优化上做的一些尝试以及具体的优化手段，希望对大家有一定的借鉴意义。
架构模型
一个好的架构模型设计不仅能让系统有很好的可扩展性，同时也能在服务能力上有很好的体现。除此之外，在设计上多考虑数据的抽象、模块的划分、工具链的完善，这样不仅能让软件具有更灵活的扩展能力、服务能力更高，也提高系统的稳定性和健壮性以及可维护性。
在数据抽象层面抽象pubsub 数据集合，用于消息的分发和处理。模块划分层面我们将服务一分为三：内部通讯（grpcsrv）、外部服务（mqttsrv）、连接管理（session）。工具链的方面我们构建了自动化测试，系统 mock ，压测工具。美图长连接服务架构设计如下：图一架构图从架构图中我们可以清晰地看到由7 个模块组成，分别是：conf 、grpcsrv 、mqttsrv、session、pubsub、packet、util ，每个模块的作用如下：
conf ：配置管理中心，负责服务配置的初始化，基本字段校验。
grpcsrv ：grpc 服务，集群内部信息交互协调。
mqttsrv ：mqtt 服务，接收客户端连接，同时支持单进程多端口 MQTT 服务。
session ：会话模块，管理客户端状态变化，MQTT 信息的收发。
pubsub ：发布订阅模块，按照 Topic 维度保存 session 并发布 Topic 通知给 session。
packet：协议解析模块，负责 MQTT 协议包解析。
util ：工具包，目前集成监控、日志、grpc 客户端、调度上报四个子模块。
Go 的内存管理
众所周知，Go 是一门自带垃圾回收机制的语言，内存管理参照 tcmalloc 实现，使用连续虚拟地址，以页( 8k )为单位、多级缓存进行管理。针对小于16 byte 直接使用Go的上下文P中的mcache分配，大于 32 kb 直接在 mheap 申请，剩下的先使用当前 P 的 mcache 中对应的 size class 分配 ，如果 mcache 对应的 size class 的 span 已经没有可用的块，则向 mcentral 请求。如果 mcentral 也没有可用的块，则向 mheap 申请，并切分。如果 mheap 也没有合适的 span，则向操作系统申请。
Go 在内存统计方面做的也是相当出色，提供细粒度的内存分配、GC 回收、goroutine 管理等统计数据。在优化过程中，一些数据能帮助我们发现和分析问题，在介绍优化之前，我们先来看看哪些参数需要关注，其统计参数如下：
go_memstats_sys_bytes ：进程从操作系统获得的内存的总字节数 ，其中包含 Go 运行时的堆、栈和其他内部数据结构保留的虚拟地址空间。
go_memstats_heap_inuse_bytes：在 spans 中正在使用的字节。其中不包含可能已经返回到操作系统，或者可以重用进行堆分配，或者可以将作为堆栈内存重用的字节。
go_memstats_heap_idle_bytes：在 spans 中空闲的字节。
go_memstats_stack_sys_bytes：栈内存字节，主要用于 goroutine 栈内存的分配。
在内存监控中根据Go 将堆的虚拟地址空间划分为 span ，即对内存8K或更大的连续区域进行统计。span 可能处于以下三种状态之一 ：
idle 不包含对象或其他数据，空闲空间的物理内存可以释放回 OS (但虚拟地址空间永远不会释放)，或者可以将其转换为使用中或栈空间；
inuse 至少包含一个堆对象，并且可能有空闲空间来分配更多的堆对象；
stack span 用于 goroutine 栈，栈不被认为是堆的一部分。span 可以在堆和堆栈内存之间更改，但它从来不会同时用于两者。
此外有一部分统计没有从堆内存中分配的运行时内部结构（通常因为它们是实现堆的一部分），与堆栈内存不同，分配给这些结构的任何内存都专用于这些结构，这些主要用于调试运行时内存开销。
虽然Go 拥有了丰富的标准库、语言层面支持并发、内置runtime，但相比C/C++ 完成相同逻辑的情况下 Go 消耗内存相对增多。在程序的运行过程中，它的 stack 内存会随着使用而自动扩容，但在 stack 内存回收采用惰性回收方式，一定程度的导致内存消耗增多，此外还有GC 机制也会带来额外内存的消耗。
Go 提供了三种内存回收机制：定时触发，按量触发，手动触发。在内存垃圾少量的情况下，Go 可以良好的运行。但是无论采用哪种触发方式，由于在海量用户服务的情况下造成的垃圾内存是巨大的，在 GC 执行过程中服务都会感觉明显的卡顿。这些也是目前长连接服务面对的难题，在下文中我将会逐一介绍我们如何减少和解决问题的产生的具体实践。
优化之路
在了解架构设计、Go 的内存管理、基础监控后，相信大家已经对当前系统有了一个大致的认识，先给大家展示一下内存优化的成果，下表一是内存优化前后的对比表，在线连接数基本相同的情况下，进程内存占用大幅度降低，其中 stack 申请内存降低约 5.9 G，其次 heap 使用内存降低 0.9 G，other 申请内存也小幅下降。那么我们是如何做到内存降低的呢？那接下来我将会把我们团队关于进行内存优化的探索和大家聊一聊。
在优化前随机抽取线上一台机器进行分析内存，通过监控发现当前节点进程占用虚拟内存为22.3 G，堆区使用的内存占用 5.2 G ，堆区未归还内存为 8.9 G，栈区内存为 7.25 G，其它约占用 0.9 G，连接数为 225 K。
我们简单进行换算，可以看出平均一个链接占用的内存分别为：堆：23K，栈：32K。通过对比业内长连接服务的数据可以看出单个链接占用的内存偏大，根据监控数据和内存分配原理分析主要原因在：goroutine 占用、session 状态信息、pubsub 模块占用，我们打算从业务、程序、网络模式三个方面进行优化。
业务优化
上文中提到 session 模块主要是用于处理消息的收发，在实现时考虑到在通常场景中业务的消息生产大于客户端消息的消费速度的情况，为了缓解这种状况，设计时引入消息的缓冲队列，这种做法同样也有助于做客户端消息的流控。
缓冲消息队列借助chan 实现 ，chan 大小根据经验将初始化默认配置为 128 。但在目前线上推送的场景中，我们发现，消息的生产一般小于消费的速度，128 缓冲大小明显偏大，因此我们把长度调整为 16 ，减少内存的分配。
在设计中按照topic 对客户端进行分组管理的算法中，采用空间换时间的方式，组合 map 和 list 两种数据结构对于客户端集合操作提供O（1）的删除、O（1）的添加、O（n）的遍历。数据的删除采用标记删除方式，使用辅助 slice 结构进行记录，只有到达预设阈值才会进行真正的删除。虽然标记删除提高了遍历和添加的性能，但也同样带来了内存损耗问题。
大家一定好奇什么样的场景需要提供这样的复杂度，在实际中其场景有以下两种情况：
在实际的网络场景中，客户端随时都可能由于网络的不稳定断开或者重新建联，因此集合的增加和删除需要在常数范围内。
在消息发布的流程中，采用遍历集合逐一发布通知方式，但随着单个topic 上的用户量的增加，经常会出现单个 topic 用户集合消息过热的问题，耗时太久导致消息挤压，因此针对集合的遍历当然也要求尽量快。
通过benchamrk 数据分析，在标记回收 slice 长度在 1000 时，可以提供最佳的性能，因此默认配置阈值为 1000。在线上服务中，无特殊情况都是采用默认配置。但在当前推送服务的使用中，发现标记删除和延迟回收机制好处甚微，主要是因为 topic 和客户端为 1 : 1 方式，也就是不存在客户端集合，因此调整回收阈值大小为 2，减少无效内存占用。
上述所有优化，只要简单调整配置后服务灰度上线即可，在设计实现时通过conf 模块动态配置，降低了服务的开发和维护成本。通过监控对比优化效果如下表，在优化后在线连接数比优化的在线连接更多的情况下， heap 使用内存使用数量由原来的 4.16G 下降到了 3.5G ，降低了约 0.66 G。
golang 代码优化
在实现上面展示的架构的时候发现在session 模块 和 mqttsrv 模块之间存在很多共享变量，目前实现方式都是采用指针或者值拷贝的，由于 session的数量和客户端数据量成正比也就导致消耗大量内存用于共享数据，这不仅仅增加 GC 压力，同样对于内存的消耗也是巨大的。就此问题思考再三，参考系统的库 context 的设计在架构中也抽象 context 包负责模块之间交互信息传递，统一分配内存。此外还参考他人减少临时变量的分配的优化方式，提高系统运行效率。主要优化角度参考如下：
在频繁申请内存的地方，使用pool 方式进行内存管理
小对象合并成结构体一次分配，减少内存分配次数
缓存区内容一次分配足够大小空间，并适当复用
slice 和 map 采 make 创建时，预估大小指定容量
调用栈避免申请较多的临时对象
减少[]byte 与 string 之间转换，尽量采用 []byte 来字符串处理
目前系统具被完备的单元测试、集成测试，因此经过一周的快速的开发重构后灰度上线监控数据对比如下表：在基本相同的连接数上，heap 使用内存约占用降低 0.27G，stack 申请内存占用降低 3.81G。为什么 stack 会大幅度降低呢？
通过设置stackDebug 重新编译程序追查程序运行过程，优化前 goroutine 栈的大多数在内存为 16K，通过减少临时变量的分配，拆分大函数处理逻辑，有效的减少触发栈的内存扩容（详细分析见参考文章），优化后 goroutine 栈内存降低到 8 K。一个连接需要启动两个 goroutine 负责数据的读和写，粗略计算一个连接减少约 16 K 的内存，23 w 连接约降低 3.68 G 内存。
网络模型优化
在Go 语言的网络编程中经典的实现都是采用同步处理方式，启动两个 goroutine 分别处理读和写请求，goroutine 也不像 thread ，它是轻量级的。但对于一百万连接的情况，这种设计模式至少要启动两百万的 goroutine，其中一个 goroutine 使用栈的大小在 2 KB 到 8KB， 对于资源的消耗也是极大的。在大多数场景中，只有少数连接是有数据处理，大部分 goroutine 阻塞 IO 处理中。在因此可以借鉴 C 语言的设计，在程序中使用 epoll 模型做事件分发，只有活跃连接才会启动 goroutine 处理业务，基于这种思想修改网络处理流程。
网络模型修改测试完成后开始灰度上线，通过监控数据对比如下表：在优化后比优化前的连接数多10 K的情况下，heap 使用内存降低 0.33 G，stack 申请内存降低 2.34 G，优化效果显著。
总结
在经过业务优化，临时内存优化，网络模型优化操作后，线上服务保证21w 长连接在线实际内存占用约为 5.1 G。简单进行压测 100w 连接只完成建立连接，不进行其他操作约占用 10 G。长连接服务内存优化已经取得阶段性的成功，但是这仅仅是我们团队的一小步，未来还有更多的工作要做：网络链路、服务能力，存储优化等，这些都是亟待探索的方向。如果大家有什么好的想法，欢迎与我们团队分享，共同探讨。
bifrost项目目前我们有开源计划，敬请大家期待。
参考文章
go tool pprof 使用介绍 ：https://segmentfault.com/a/1190000016412013
Go 内存监控介绍：https://golang.org/src/runtime/mstats.go
Go 内存优化介绍：https://blog.golang.org/profiling-go-programs
高性能Go服务内存分配：https://segment.com/blog/alloc ... vices
Go stack 优化分析：https://studygolang.com/article
随着科技的飞速发展，技术的日新月异，长连接的运用场景日益增多。不仅在后端服务中被广泛运用，比较常见的有数据库的访问、服务内部状态的协调等，而且在 App 端的消息推送、聊天信息、直播弹字幕等场景长连接服务也是优选方案。长连接服务的重要性也在各个场合被业界专家不断提及，与此同时也引起了更为广泛地关注和讨论，各大公司也开始构建自己的长连接服务。
美图公司于2016 年初开始构建长连接服务，与此同时， Go 在编程语言领域异军突起，考虑到其丰富的编程库，完善的工具链，简单高效的并发模型等优势，使我们最终选择 Go 去作为实现长连接服务的语言。在通信协议的选择上，考虑到 MQTT 协议的轻量、简单、易于实现的优点，选择了 MQTT 协议作为数据交互的载体。其整体的架构会在下文中做相应地介绍。
美图长连接服务（项目内部代号为bifrost ）已经历时三年，在这三年的时间里，长连接服务经过了业务的检验，同时也经历了服务的重构，存储的升级等，长连接服务从之前支持单机二十几万连接到目前可以支撑单机百万连接。在大多数长连接服务中存在一个共性问题，那就是内存占用过高，我们经常发现单个节点几十万的长连接，内存却占用十几G 甚至更多，有哪些手段能降低内存呢？
本文将从多个角度介绍长连接服务在内存优化路上的探索，首先会先通过介绍当前服务的架构模型，Go 语言的内存管理，让大家清晰地了解我们内存优化的方向和关注的重要数据。后面会重点介绍我们在内存优化上做的一些尝试以及具体的优化手段，希望对大家有一定的借鉴意义。
架构模型
一个好的架构模型设计不仅能让系统有很好的可扩展性，同时也能在服务能力上有很好的体现。除此之外，在设计上多考虑数据的抽象、模块的划分、工具链的完善，这样不仅能让软件具有更灵活的扩展能力、服务能力更高，也提高系统的稳定性和健壮性以及可维护性。
在数据抽象层面抽象pubsub 数据集合，用于消息的分发和处理。模块划分层面我们将服务一分为三：内部通讯（grpcsrv）、外部服务（mqttsrv）、连接管理（session）。工具链的方面我们构建了自动化测试，系统 mock ，压测工具。美图长连接服务架构设计如下：图一架构图从架构图中我们可以清晰地看到由7 个模块组成，分别是：conf 、grpcsrv 、mqttsrv、session、pubsub、packet、util ，每个模块的作用如下：
conf ：配置管理中心，负责服务配置的初始化，基本字段校验。
grpcsrv ：grpc 服务，集群内部信息交互协调。
mqttsrv ：mqtt 服务，接收客户端连接，同时支持单进程多端口 MQTT 服务。
session ：会话模块，管理客户端状态变化，MQTT 信息的收发。
pubsub ：发布订阅模块，按照 Topic 维度保存 session 并发布 Topic 通知给 session。
packet：协议解析模块，负责 MQTT 协议包解析。
util ：工具包，目前集成监控、日志、grpc 客户端、调度上报四个子模块。
Go 的内存管理
众所周知，Go 是一门自带垃圾回收机制的语言，内存管理参照 tcmalloc 实现，使用连续虚拟地址，以页( 8k )为单位、多级缓存进行管理。针对小于16 byte 直接使用Go的上下文P中的mcache分配，大于 32 kb 直接在 mheap 申请，剩下的先使用当前 P 的 mcache 中对应的 size class 分配 ，如果 mcache 对应的 size class 的 span 已经没有可用的块，则向 mcentral 请求。如果 mcentral 也没有可用的块，则向 mheap 申请，并切分。如果 mheap 也没有合适的 span，则向操作系统申请。
Go 在内存统计方面做的也是相当出色，提供细粒度的内存分配、GC 回收、goroutine 管理等统计数据。在优化过程中，一些数据能帮助我们发现和分析问题，在介绍优化之前，我们先来看看哪些参数需要关注，其统计参数如下：
go_memstats_sys_bytes ：进程从操作系统获得的内存的总字节数 ，其中包含 Go 运行时的堆、栈和其他内部数据结构保留的虚拟地址空间。
go_memstats_heap_inuse_bytes：在 spans 中正在使用的字节。其中不包含可能已经返回到操作系统，或者可以重用进行堆分配，或者可以将作为堆栈内存重用的字节。
go_memstats_heap_idle_bytes：在 spans 中空闲的字节。
go_memstats_stack_sys_bytes：栈内存字节，主要用于 goroutine 栈内存的分配。
在内存监控中根据Go 将堆的虚拟地址空间划分为 span ，即对内存8K或更大的连续区域进行统计。span 可能处于以下三种状态之一 ：
idle 不包含对象或其他数据，空闲空间的物理内存可以释放回 OS (但虚拟地址空间永远不会释放)，或者可以将其转换为使用中或栈空间；
inuse 至少包含一个堆对象，并且可能有空闲空间来分配更多的堆对象；
stack span 用于 goroutine 栈，栈不被认为是堆的一部分。span 可以在堆和堆栈内存之间更改，但它从来不会同时用于两者。
此外有一部分统计没有从堆内存中分配的运行时内部结构（通常因为它们是实现堆的一部分），与堆栈内存不同，分配给这些结构的任何内存都专用于这些结构，这些主要用于调试运行时内存开销。
虽然Go 拥有了丰富的标准库、语言层面支持并发、内置runtime，但相比C/C++ 完成相同逻辑的情况下 Go 消耗内存相对增多。在程序的运行过程中，它的 stack 内存会随着使用而自动扩容，但在 stack 内存回收采用惰性回收方式，一定程度的导致内存消耗增多，此外还有GC 机制也会带来额外内存的消耗。
Go 提供了三种内存回收机制：定时触发，按量触发，手动触发。在内存垃圾少量的情况下，Go 可以良好的运行。但是无论采用哪种触发方式，由于在海量用户服务的情况下造成的垃圾内存是巨大的，在 GC 执行过程中服务都会感觉明显的卡顿。这些也是目前长连接服务面对的难题，在下文中我将会逐一介绍我们如何减少和解决问题的产生的具体实践。
优化之路
在了解架构设计、Go 的内存管理、基础监控后，相信大家已经对当前系统有了一个大致的认识，先给大家展示一下内存优化的成果，下表一是内存优化前后的对比表，在线连接数基本相同的情况下，进程内存占用大幅度降低，其中 stack 申请内存降低约 5.9 G，其次 heap 使用内存降低 0.9 G，other 申请内存也小幅下降。那么我们是如何做到内存降低的呢？那接下来我将会把我们团队关于进行内存优化的探索和大家聊一聊。
在优化前随机抽取线上一台机器进行分析内存，通过监控发现当前节点进程占用虚拟内存为22.3 G，堆区使用的内存占用 5.2 G ，堆区未归还内存为 8.9 G，栈区内存为 7.25 G，其它约占用 0.9 G，连接数为 225 K。
我们简单进行换算，可以看出平均一个链接占用的内存分别为：堆：23K，栈：32K。通过对比业内长连接服务的数据可以看出单个链接占用的内存偏大，根据监控数据和内存分配原理分析主要原因在：goroutine 占用、session 状态信息、pubsub 模块占用，我们打算从业务、程序、网络模式三个方面进行优化。
业务优化
上文中提到 session 模块主要是用于处理消息的收发，在实现时考虑到在通常场景中业务的消息生产大于客户端消息的消费速度的情况，为了缓解这种状况，设计时引入消息的缓冲队列，这种做法同样也有助于做客户端消息的流控。
缓冲消息队列借助chan 实现 ，chan 大小根据经验将初始化默认配置为 128 。但在目前线上推送的场景中，我们发现，消息的生产一般小于消费的速度，128 缓冲大小明显偏大，因此我们把长度调整为 16 ，减少内存的分配。
在设计中按照topic 对客户端进行分组管理的算法中，采用空间换时间的方式，组合 map 和 list 两种数据结构对于客户端集合操作提供O（1）的删除、O（1）的添加、O（n）的遍历。数据的删除采用标记删除方式，使用辅助 slice 结构进行记录，只有到达预设阈值才会进行真正的删除。虽然标记删除提高了遍历和添加的性能，但也同样带来了内存损耗问题。
大家一定好奇什么样的场景需要提供这样的复杂度，在实际中其场景有以下两种情况：
在实际的网络场景中，客户端随时都可能由于网络的不稳定断开或者重新建联，因此集合的增加和删除需要在常数范围内。
在消息发布的流程中，采用遍历集合逐一发布通知方式，但随着单个topic 上的用户量的增加，经常会出现单个 topic 用户集合消息过热的问题，耗时太久导致消息挤压，因此针对集合的遍历当然也要求尽量快。
通过benchamrk 数据分析，在标记回收 slice 长度在 1000 时，可以提供最佳的性能，因此默认配置阈值为 1000。在线上服务中，无特殊情况都是采用默认配置。但在当前推送服务的使用中，发现标记删除和延迟回收机制好处甚微，主要是因为 topic 和客户端为 1 : 1 方式，也就是不存在客户端集合，因此调整回收阈值大小为 2，减少无效内存占用。
上述所有优化，只要简单调整配置后服务灰度上线即可，在设计实现时通过conf 模块动态配置，降低了服务的开发和维护成本。通过监控对比优化效果如下表，在优化后在线连接数比优化的在线连接更多的情况下， heap 使用内存使用数量由原来的 4.16G 下降到了 3.5G ，降低了约 0.66 G。
golang 代码优化
在实现上面展示的架构的时候发现在session 模块 和 mqttsrv 模块之间存在很多共享变量，目前实现方式都是采用指针或者值拷贝的，由于 session的数量和客户端数据量成正比也就导致消耗大量内存用于共享数据，这不仅仅增加 GC 压力，同样对于内存的消耗也是巨大的。就此问题思考再三，参考系统的库 context 的设计在架构中也抽象 context 包负责模块之间交互信息传递，统一分配内存。此外还参考他人减少临时变量的分配的优化方式，提高系统运行效率。主要优化角度参考如下：
在频繁申请内存的地方，使用pool 方式进行内存管理
小对象合并成结构体一次分配，减少内存分配次数
缓存区内容一次分配足够大小空间，并适当复用
slice 和 map 采 make 创建时，预估大小指定容量
调用栈避免申请较多的临时对象
减少[]byte 与 string 之间转换，尽量采用 []byte 来字符串处理
目前系统具被完备的单元测试、集成测试，因此经过一周的快速的开发重构后灰度上线监控数据对比如下表：在基本相同的连接数上，heap 使用内存约占用降低 0.27G，stack 申请内存占用降低 3.81G。为什么 stack 会大幅度降低呢？
通过设置stackDebug 重新编译程序追查程序运行过程，优化前 goroutine 栈的大多数在内存为 16K，通过减少临时变量的分配，拆分大函数处理逻辑，有效的减少触发栈的内存扩容（详细分析见参考文章），优化后 goroutine 栈内存降低到 8 K。一个连接需要启动两个 goroutine 负责数据的读和写，粗略计算一个连接减少约 16 K 的内存，23 w 连接约降低 3.68 G 内存。
网络模型优化
在Go 语言的网络编程中经典的实现都是采用同步处理方式，启动两个 goroutine 分别处理读和写请求，goroutine 也不像 thread ，它是轻量级的。但对于一百万连接的情况，这种设计模式至少要启动两百万的 goroutine，其中一个 goroutine 使用栈的大小在 2 KB 到 8KB， 对于资源的消耗也是极大的。在大多数场景中，只有少数连接是有数据处理，大部分 goroutine 阻塞 IO 处理中。在因此可以借鉴 C 语言的设计，在程序中使用 epoll 模型做事件分发，只有活跃连接才会启动 goroutine 处理业务，基于这种思想修改网络处理流程。
网络模型修改测试完成后开始灰度上线，通过监控数据对比如下表：在优化后比优化前的连接数多10 K的情况下，heap 使用内存降低 0.33 G，stack 申请内存降低 2.34 G，优化效果显著。
总结
在经过业务优化，临时内存优化，网络模型优化操作后，线上服务保证21w 长连接在线实际内存占用约为 5.1 G。简单进行压测 100w 连接只完成建立连接，不进行其他操作约占用 10 G。长连接服务内存优化已经取得阶段性的成功，但是这仅仅是我们团队的一小步，未来还有更多的工作要做：网络链路、服务能力，存储优化等，这些都是亟待探索的方向。如果大家有什么好的想法，欢迎与我们团队分享，共同探讨。
bifrost项目目前我们有开源计划，敬请大家期待。
参考文章
go tool pprof 使用介绍 ：https://segmentfault.com/a/1190000016412013
Go 内存监控介绍：https://golang.org/src/runtime/mstats.go
Go 内存优化介绍：https://blog.golang.org/profiling-go-programs
高性能Go服务内存分配：https://segment.com/blog/alloc ... vices
Go stack 优化分析：https://studygolang.com/article
0
评论
【源码下载】一款使用环信SDK实现的开源--社交demo
QWK 发表了文章 • 423 次浏览 • 2019-11-25 16:58
React webIm demo简介 --（集成环信SDK）
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
同时我们也提供了[Vue版demo] (https://github.com/easemob/webim-vue-demo)。
项目截图：
项目地址：https://github.com/easemob/webim
开发环境
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装
- 在/demo目录下执行 npm i
- 运行demo
- cd demo && npm start （requires node@>=6）
http://localhost:3001
- cd demo && HTTPS=true npm start (webrtc supports HTTPS only)
https://localhost:3001
注意：只有在https的情况才支持语音视频功能
打包发布demo
cd demo && npm run build /demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)
FIX: 这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3
FIX: 请检查node版本是否是v6.0+
项目模块
本项目包含两部分：
一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge
最后的最后如果你有更好的建议，或者你的疑惑，请随时给我留言。
查看全部
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
同时我们也提供了[Vue版demo] (https://github.com/easemob/webim-vue-demo)。
项目截图：
项目地址：https://github.com/easemob/webim
开发环境
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装
- 在/demo目录下执行 npm i
- 运行demo
- cd demo && npm start （requires node@>=6）
http://localhost:3001
- cd demo && HTTPS=true npm start (webrtc supports HTTPS only)
https://localhost:3001
注意：只有在https的情况才支持语音视频功能
打包发布demo
cd demo && npm run build /demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)
FIX: 这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3
FIX: 请检查node版本是否是v6.0+
项目模块
本项目包含两部分：
一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge
最后的最后如果你有更好的建议，或者你的疑惑，请随时给我留言。
查看全部
React webIm demo简介 --（集成环信SDK）
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
同时我们也提供了[Vue版demo] (https://github.com/easemob/webim-vue-demo)。
项目截图：
项目地址：https://github.com/easemob/webim
开发环境
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装
- 在/demo目录下执行
- 运行demo
注意：只有在https的情况才支持语音视频功能
打包发布demo
可能遇见的问题：
1. 如果在npm i的过程中遇到
2. 执行npm start时如果出现
项目模块
本项目包含两部分：
一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge
最后的最后如果你有更好的建议，或者你的疑惑，请随时给我留言。
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
同时我们也提供了[Vue版demo] (https://github.com/easemob/webim-vue-demo)。
项目截图：
项目地址：https://github.com/easemob/webim
开发环境
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装
- 在/demo目录下执行
npm i
- 运行demo
- cd demo && npm start （requires node@>=6）
http://localhost:3001
- cd demo && HTTPS=true npm start (webrtc supports HTTPS only)
https://localhost:3001
注意：只有在https的情况才支持语音视频功能
打包发布demo
cd demo && npm run build/demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)
FIX: 这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3
FIX: 请检查node版本是否是v6.0+ 项目模块
本项目包含两部分：
一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge
最后的最后如果你有更好的建议，或者你的疑惑，请随时给我留言。
0
评论
【源码下载】一款使用环信SDK实现的开源--社交demo
QWK 发表了文章 • 287 次浏览 • 2019-11-25 16:58
React webIm demo简介 --（集成环信SDK）
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
同时我们也提供了[Vue版demo] https://github.com/easemob/webim-vue-demo
项目截图：
项目地址：https://github.com/easemob/webim
开发环境:
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装：
- 在/demo目录下执行
npm i
- 运行demo
- cd demo && npm start （requires node@>=6） http://localhost:3001注意：只有在https的情况才支持语音视频功能
- 打包发布demo
cd demo && npm run build /demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)FIX:
这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3 FIX: 请检查node版本是否是v6.0+
项目模块
本项目包含两部分：一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge 查看全部
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
同时我们也提供了[Vue版demo] https://github.com/easemob/webim-vue-demo
项目截图：
项目地址：https://github.com/easemob/webim
开发环境:
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装：
- 在/demo目录下执行
npm i
- 运行demo
- cd demo && npm start （requires node@>=6） http://localhost:3001注意：只有在https的情况才支持语音视频功能
- 打包发布demo
cd demo && npm run build /demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)FIX:
这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3 FIX: 请检查node版本是否是v6.0+
项目模块
本项目包含两部分：一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge 查看全部
React webIm demo简介 --（集成环信SDK）
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
项目截图：
项目地址：https://github.com/easemob/webim
开发环境:
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装：
- 在/demo目录下执行
npm i
- 运行demo
- cd demo && npm start （requires node@>=6） http://localhost:3001注意：只有在https的情况才支持语音视频功能
- 打包发布demo
cd demo && npm run build /demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)FIX:
这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3 FIX: 请检查node版本是否是v6.0+
项目模块
本项目包含两部分：一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge
webIm demo 是基于环信sdk开发的一款具有单聊、群聊、聊天室、音视频等功能的应用，为了react用户能够快速集成环信 im sdk和音视频sdk，我们特使用了react全家桶，为大家提供参考。
- 同时我们也提供了[Vue版demo] https://github.com/easemob/webim-vue-demo
项目截图：
项目地址：https://github.com/easemob/webim
开发环境:
完全基于React + Redux的单向数据流，引入ant-design组件库。
响应式布局, 一套Demo同时支持PC和H5,自适应不同终端屏幕尺寸
支持所有的现代浏览器(不支持IE6-11)
初始化安装：
- 在/demo目录下执行
npm i
- 运行demo
- cd demo && npm start （requires node@>=6） http://localhost:3001注意：只有在https的情况才支持语音视频功能
- 打包发布demo
cd demo && npm run build /demo/build 目录下的就是可以运行和部署的版本
可能遇见的问题：
1. 如果在npm i的过程中遇到
> phantomjs-prebuilt@2.1.14 install /Users/will/work/my-project/node_modules/phantomjs-prebuilt> node install.jsPhantomJS not found on PATHDownloading https://github.com/Medium/phan ... aving to /var/folders/mh/2ptfthxj2qb49jscj1b0gjsm0000gn/T/phantomjs/phantomjs-2.1.1-macosx.zipReceiving...Error making request.Error: connect ETIMEDOUT 54.231.113.227:443 at Object.exports._errnoException (util.js:1018:11) at exports._exceptionWithHostPort (util.js:1041:20) at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1090:14)FIX:
这个问题，可以尝试 PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/ npm install --save-dev phantomjs-prebuilt 来解决
2. 执行npm start时如果出现
> node scripts/start.js/Users/wenke/www/web-im/demo/scripts/start.js:23const { ^SyntaxError: Unexpected token { at exports.runInThisContext (vm.js:53:16) at Module._compile (module.js:373:25) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Function.Module.runMain (module.js:441:10) at startup (node.js:139:18) at node.js:974:3 FIX: 请检查node版本是否是v6.0+
项目模块
本项目包含两部分：一部分是项目主模块，这部分主要包含了项目的业务逻辑，比如增，删好友、音视频聊天、信息修改、群设置等
另一部分是 环信sdk集成（包含音视频sdk）
src项目结构
更多关于环信sdk[集成文档]
http://docs-im.easemob.com/im/web/intro/start
参与贡献
如果你有什么好的想法，或者好的实现，可以通过下边的步骤参与进来，让我们一起把这个项目做得更好，欢迎参与
1.Fork本仓库
2.新建feature_xxx分支 (单独创建一个实现你自己想法的分支)
3.提交代码
4.新建Pull Request
5.等待我们的Review & Merge
1
回复
webim 怎么样输出最近联系人到h5页面
lizg 回复了问题 • 2 人关注 • 629 次浏览 • 2019-11-22 18:10
1
评论
获取好友列表总是失败呢，type=16
vtchg 发表了文章 • 416 次浏览 • 2019-11-22 16:54
明明是先登陆，后监听，再是获取好友列表。怎么会先执行第三步呢？
明明是先登陆，后监听，再是获取好友列表。怎么会先执行第三步呢？
0
评论
webim 怎么样输出最近联系人到h5页面
vtchg 发表了文章 • 332 次浏览 • 2019-11-22 11:16
webim 怎么样输出最近联系人到h5页面
webim 怎么样输出最近联系人到h5页面
1
最佳
导入环信Demo报错
lizg 回复了问题 • 2 人关注 • 717 次浏览 • 2019-11-19 17:12
2
回复
Android 视频通话可以默认就打开后置摄像头吗？
lizg 回复了问题 • 2 人关注 • 754 次浏览 • 2019-11-13 17:23
1
回复
kefu-android-demo运行不了
lizg 回复了问题 • 2 人关注 • 784 次浏览 • 2019-11-11 09:44
3
回复
环信客服 退出登录时，偶尔会包空指针崩溃
zhaoliang 回复了问题 • 2 人关注 • 806 次浏览 • 2019-11-05 14:19
1
回复
小程序怎么接收陌生人的消息？
lizg 回复了问题 • 2 人关注 • 894 次浏览 • 2019-10-28 17:57
1
回复
小程序SDK：文档里发送文件、视频消息的方法错误
lizg 回复了问题 • 2 人关注 • 861 次浏览 • 2019-10-24 10:28
2
回复
接口返回的这信息是这什么错误？
DR22306565 回复了问题 • 2 人关注 • 2764 次浏览 • 2019-10-23 21:25
0
评论
客服云 查看IM用户上传推送证书
coinci 发表了文章 • 397 次浏览 • 2019-10-22 15:17
进入appkey console后台查看已注册用户 上传推送证书
****1.快速创建的关联
切换到管理员模式--渠道管理---手机APP
APP信息页面点击 蓝色字体 直接登录IM关联后台，可以进入快速创建的关联后台，点击appkey后可查看IM用户和证书信息
****2.手动绑定的管理 需要单独登录IMconsole后台查看
IMconsole后台登录地址：
https://console.easemob.com/user/login 查看全部
****1.快速创建的关联
切换到管理员模式--渠道管理---手机APP
APP信息页面点击 蓝色字体 直接登录IM关联后台，可以进入快速创建的关联后台，点击appkey后可查看IM用户和证书信息
****2.手动绑定的管理 需要单独登录IMconsole后台查看
IMconsole后台登录地址：
https://console.easemob.com/user/login 查看全部
进入appkey console后台查看已注册用户 上传推送证书
****1.快速创建的关联
切换到管理员模式--渠道管理---手机APP
APP信息页面点击 蓝色字体 直接登录IM关联后台，可以进入快速创建的关联后台，点击appkey后可查看IM用户和证书信息
****2.手动绑定的管理 需要单独登录IMconsole后台查看
IMconsole后台登录地址：
https://console.easemob.com/user/login
****1.快速创建的关联
切换到管理员模式--渠道管理---手机APP
APP信息页面点击 蓝色字体 直接登录IM关联后台，可以进入快速创建的关联后台，点击appkey后可查看IM用户和证书信息
****2.手动绑定的管理 需要单独登录IMconsole后台查看
IMconsole后台登录地址：
https://console.easemob.com/user/login
0
评论
客服云 查看有哪些会话在待接入排队过
coinci 发表了文章 • 394 次浏览 • 2019-10-22 15:17
查看有哪些会话在待接入排队过
（管理员模式--会话统计--排队统计）可以查看该报表，此报表为增值功能，标准版坐席没有，需要单独联系商务经理开通
文档：
http://docs.easemob.com/cs/200 ... %25A1
另外该 报表中的排队次数，可以点击该数量之后弹窗显示相关会话数据
相关会话可以导出后查看具体信息
弹窗列表显示的 数据：
客服一列（如果排队的会话被客服接起这里会显示接待的客服，如果没有任何一个客服接入过直接被关闭的显示为空）
开始时间（表示客服接入或者转入会话的时间，如果没有被客服接入过，显示为空）
会话标签（如果没有打过标签，此处也为空） 查看全部
（管理员模式--会话统计--排队统计）可以查看该报表，此报表为增值功能，标准版坐席没有，需要单独联系商务经理开通
文档：
http://docs.easemob.com/cs/200 ... %25A1
另外该 报表中的排队次数，可以点击该数量之后弹窗显示相关会话数据
相关会话可以导出后查看具体信息
弹窗列表显示的 数据：
客服一列（如果排队的会话被客服接起这里会显示接待的客服，如果没有任何一个客服接入过直接被关闭的显示为空）
开始时间（表示客服接入或者转入会话的时间，如果没有被客服接入过，显示为空）
会话标签（如果没有打过标签，此处也为空） 查看全部
查看有哪些会话在待接入排队过
（管理员模式--会话统计--排队统计）可以查看该报表，此报表为增值功能，标准版坐席没有，需要单独联系商务经理开通
文档：
http://docs.easemob.com/cs/200 ... %25A1
另外该 报表中的排队次数，可以点击该数量之后弹窗显示相关会话数据
相关会话可以导出后查看具体信息
弹窗列表显示的 数据：
客服一列（如果排队的会话被客服接起这里会显示接待的客服，如果没有任何一个客服接入过直接被关闭的显示为空）
开始时间（表示客服接入或者转入会话的时间，如果没有被客服接入过，显示为空）
会话标签（如果没有打过标签，此处也为空）
（管理员模式--会话统计--排队统计）可以查看该报表，此报表为增值功能，标准版坐席没有，需要单独联系商务经理开通
文档：
http://docs.easemob.com/cs/200 ... %25A1
另外该 报表中的排队次数，可以点击该数量之后弹窗显示相关会话数据
相关会话可以导出后查看具体信息
弹窗列表显示的 数据：
客服一列（如果排队的会话被客服接起这里会显示接待的客服，如果没有任何一个客服接入过直接被关闭的显示为空）
开始时间（表示客服接入或者转入会话的时间，如果没有被客服接入过，显示为空）
会话标签（如果没有打过标签，此处也为空）
0
评论
IM 和 客服 并存开发指南—iOS篇
kijieoeew 发表了文章 • 692 次浏览 • 2019-10-18 17:13
如果觉得哪里描述的不清晰，可评论内指出，会不定期更新。
一、SDK 介绍
HelpDesk.framework 为 客服SDK（带实时音视频）
HelpDeskLite.framework 为 客服SDK（不带实时音视频）
Hyphenate.framework 为 IM SDK（带实时音视频）
HyphenateLite.framework 为 IM SDK（不带实时音视频）
环信客服SDK 基于 IM SDK 3.x , 如果同时集成 客服 和 IM，只需要在初始化、登录、登出操作时使用客服SDK 提供的相应API，IM 的其他API均不受影响。
UI 部分集成需要分别导入 HelpDeskUI 和 IM demo 中的UI文件（也可以自定义UI）。 下面详细介绍IM 和 客服共存的开发步骤。
二、注意事项
1、开发过程中，初始化、登录和登出，务必只使用客服访客端SDK的API。
2、需要联系商务开通客服长链接。
3、IM SDK 和客服SDK 都包括了模拟器的CPU 架构，在上传到app store时需要剔除模拟器的CPU 架构，保留 armv7、arm64，参考文档：上传appstore以及打包ipa注意事项。
三、资源准备
到环信官网下载客服访客端的开源的商城Demo源码 + SDK，下载链接：http://www.easemob.com/download/cs 选 择“iOS SDK”下载（如下图）。
到环信官网下载IM的开源的Demo源码 + SDK ，下载链接：http://www.easemob.com/download/im 选择 iOS SDK（如下图）。
下载的 IM SDK+Demo 和 客服SDK+Demo 中都有 IM 的 Hyphenate.framework 或 HyphenateLite.framework，为了保持版本的匹配，我们只使用 IM Demo 中的 UI， 而不使用 IM SDK 中 的 Hyphenate.framework 或 HyphenateLite.framework 文件。
四、集成步骤
1、阅读客服访客端SDK集成文档，集成客服，地址：http://docs.easemob.com/cs/300visitoraccess/iossdk。
2、阅读 IM 的集成文档，地址：http://docs-im.easemob.com/im/ios/sdk/prepare
3、将 IM Demo 中的 UI 文件按照自己的需求分模块导入到工程中
4、将 IM 的 UI 所依赖的第三方库集成到项目中（IM集成文档内有说明）
5、在pch文件中引入 EMHeaders.h
#ifdef __OBJC__ //包含实时音视频功能
#import <HelpDesk/HelpDesk.h>
// 若不包含实时音视频，则替换为
// #import <HelpDeskLite/HelpDeskLite.h>
#import "HelpDeskUI.h"
#import "EMHeaders.h" #endif
6、由于HelpDeskUI 和 IM UI 中都使用了 第三方库，如果工程中出现三方库重复的问题，可将重复文件删除，如果部分接口已经升级或弃用可自行升级、调整。
提供的兼容Demo介绍：
1、Demo集成了初始化sdk、登录、退出登录、IM单聊、联系客服的简单功能，处理了第三方库冲突的问题。
2、pch文件中的appkey等信息需要换成开发者自己的。
3、Demo源码下载地址： https://pan.baidu.com/s/1v1TUl-fqJNLQrtsJfWYGzw
提取码: kukb 查看全部
一、SDK 介绍
HelpDesk.framework 为 客服SDK（带实时音视频）
HelpDeskLite.framework 为 客服SDK（不带实时音视频）
Hyphenate.framework 为 IM SDK（带实时音视频）
HyphenateLite.framework 为 IM SDK（不带实时音视频）
环信客服SDK 基于 IM SDK 3.x , 如果同时集成 客服 和 IM，只需要在初始化、登录、登出操作时使用客服SDK 提供的相应API，IM 的其他API均不受影响。
UI 部分集成需要分别导入 HelpDeskUI 和 IM demo 中的UI文件（也可以自定义UI）。 下面详细介绍IM 和 客服共存的开发步骤。
二、注意事项
1、开发过程中，初始化、登录和登出，务必只使用客服访客端SDK的API。
2、需要联系商务开通客服长链接。
3、IM SDK 和客服SDK 都包括了模拟器的CPU 架构，在上传到app store时需要剔除模拟器的CPU 架构，保留 armv7、arm64，参考文档：上传appstore以及打包ipa注意事项。
三、资源准备
到环信官网下载客服访客端的开源的商城Demo源码 + SDK，下载链接：http://www.easemob.com/download/cs 选 择“iOS SDK”下载（如下图）。
到环信官网下载IM的开源的Demo源码 + SDK ，下载链接：http://www.easemob.com/download/im 选择 iOS SDK（如下图）。
下载的 IM SDK+Demo 和 客服SDK+Demo 中都有 IM 的 Hyphenate.framework 或 HyphenateLite.framework，为了保持版本的匹配，我们只使用 IM Demo 中的 UI， 而不使用 IM SDK 中 的 Hyphenate.framework 或 HyphenateLite.framework 文件。
四、集成步骤
1、阅读客服访客端SDK集成文档，集成客服，地址：http://docs.easemob.com/cs/300visitoraccess/iossdk。
2、阅读 IM 的集成文档，地址：http://docs-im.easemob.com/im/ios/sdk/prepare
3、将 IM Demo 中的 UI 文件按照自己的需求分模块导入到工程中
4、将 IM 的 UI 所依赖的第三方库集成到项目中（IM集成文档内有说明）
5、在pch文件中引入 EMHeaders.h
#ifdef __OBJC__ //包含实时音视频功能
#import <HelpDesk/HelpDesk.h>
// 若不包含实时音视频，则替换为
// #import <HelpDeskLite/HelpDeskLite.h>
#import "HelpDeskUI.h"
#import "EMHeaders.h" #endif
6、由于HelpDeskUI 和 IM UI 中都使用了 第三方库，如果工程中出现三方库重复的问题，可将重复文件删除，如果部分接口已经升级或弃用可自行升级、调整。
提供的兼容Demo介绍：
1、Demo集成了初始化sdk、登录、退出登录、IM单聊、联系客服的简单功能，处理了第三方库冲突的问题。
2、pch文件中的appkey等信息需要换成开发者自己的。
3、Demo源码下载地址： https://pan.baidu.com/s/1v1TUl-fqJNLQrtsJfWYGzw
提取码: kukb 查看全部
如果觉得哪里描述的不清晰，可评论内指出，会不定期更新。
一、SDK 介绍
HelpDesk.framework 为 客服SDK（带实时音视频）
HelpDeskLite.framework 为 客服SDK（不带实时音视频）
Hyphenate.framework 为 IM SDK（带实时音视频）
HyphenateLite.framework 为 IM SDK（不带实时音视频）
环信客服SDK 基于 IM SDK 3.x , 如果同时集成 客服 和 IM，只需要在初始化、登录、登出操作时使用客服SDK 提供的相应API，IM 的其他API均不受影响。
UI 部分集成需要分别导入 HelpDeskUI 和 IM demo 中的UI文件（也可以自定义UI）。 下面详细介绍IM 和 客服共存的开发步骤。
二、注意事项
1、开发过程中，初始化、登录和登出，务必只使用客服访客端SDK的API。
2、需要联系商务开通客服长链接。
3、IM SDK 和客服SDK 都包括了模拟器的CPU 架构，在上传到app store时需要剔除模拟器的CPU 架构，保留 armv7、arm64，参考文档：上传appstore以及打包ipa注意事项。
三、资源准备
到环信官网下载客服访客端的开源的商城Demo源码 + SDK，下载链接：http://www.easemob.com/download/cs 选 择“iOS SDK”下载（如下图）。
到环信官网下载IM的开源的Demo源码 + SDK ，下载链接：http://www.easemob.com/download/im 选择 iOS SDK（如下图）。
下载的 IM SDK+Demo 和 客服SDK+Demo 中都有 IM 的 Hyphenate.framework 或 HyphenateLite.framework，为了保持版本的匹配，我们只使用 IM Demo 中的 UI， 而不使用 IM SDK 中 的 Hyphenate.framework 或 HyphenateLite.framework 文件。
四、集成步骤
1、阅读客服访客端SDK集成文档，集成客服，地址：http://docs.easemob.com/cs/300visitoraccess/iossdk。
2、阅读 IM 的集成文档，地址：http://docs-im.easemob.com/im/ios/sdk/prepare
3、将 IM Demo 中的 UI 文件按照自己的需求分模块导入到工程中
4、将 IM 的 UI 所依赖的第三方库集成到项目中（IM集成文档内有说明）
5、在pch文件中引入 EMHeaders.h
#ifdef __OBJC__ //包含实时音视频功能
#import <HelpDesk/HelpDesk.h>
// 若不包含实时音视频，则替换为
// #import <HelpDeskLite/HelpDeskLite.h>
#import "HelpDeskUI.h"
#import "EMHeaders.h" #endif
6、由于HelpDeskUI 和 IM UI 中都使用了 第三方库，如果工程中出现三方库重复的问题，可将重复文件删除，如果部分接口已经升级或弃用可自行升级、调整。
提供的兼容Demo介绍：
1、Demo集成了初始化sdk、登录、退出登录、IM单聊、联系客服的简单功能，处理了第三方库冲突的问题。
2、pch文件中的appkey等信息需要换成开发者自己的。
3、Demo源码下载地址： https://pan.baidu.com/s/1v1TUl-fqJNLQrtsJfWYGzw
提取码: kukb
一、SDK 介绍
HelpDesk.framework 为 客服SDK（带实时音视频）
HelpDeskLite.framework 为 客服SDK（不带实时音视频）
Hyphenate.framework 为 IM SDK（带实时音视频）
HyphenateLite.framework 为 IM SDK（不带实时音视频）
环信客服SDK 基于 IM SDK 3.x , 如果同时集成 客服 和 IM，只需要在初始化、登录、登出操作时使用客服SDK 提供的相应API，IM 的其他API均不受影响。
UI 部分集成需要分别导入 HelpDeskUI 和 IM demo 中的UI文件（也可以自定义UI）。 下面详细介绍IM 和 客服共存的开发步骤。
二、注意事项
1、开发过程中，初始化、登录和登出，务必只使用客服访客端SDK的API。
2、需要联系商务开通客服长链接。
3、IM SDK 和客服SDK 都包括了模拟器的CPU 架构，在上传到app store时需要剔除模拟器的CPU 架构，保留 armv7、arm64，参考文档：上传appstore以及打包ipa注意事项。
三、资源准备
到环信官网下载客服访客端的开源的商城Demo源码 + SDK，下载链接：http://www.easemob.com/download/cs 选 择“iOS SDK”下载（如下图）。
到环信官网下载IM的开源的Demo源码 + SDK ，下载链接：http://www.easemob.com/download/im 选择 iOS SDK（如下图）。
下载的 IM SDK+Demo 和 客服SDK+Demo 中都有 IM 的 Hyphenate.framework 或 HyphenateLite.framework，为了保持版本的匹配，我们只使用 IM Demo 中的 UI， 而不使用 IM SDK 中 的 Hyphenate.framework 或 HyphenateLite.framework 文件。
四、集成步骤
1、阅读客服访客端SDK集成文档，集成客服，地址：http://docs.easemob.com/cs/300visitoraccess/iossdk。
2、阅读 IM 的集成文档，地址：http://docs-im.easemob.com/im/ios/sdk/prepare
3、将 IM Demo 中的 UI 文件按照自己的需求分模块导入到工程中
4、将 IM 的 UI 所依赖的第三方库集成到项目中（IM集成文档内有说明）
5、在pch文件中引入 EMHeaders.h
#ifdef __OBJC__ //包含实时音视频功能
#import <HelpDesk/HelpDesk.h>
// 若不包含实时音视频，则替换为
// #import <HelpDeskLite/HelpDeskLite.h>
#import "HelpDeskUI.h"
#import "EMHeaders.h" #endif
6、由于HelpDeskUI 和 IM UI 中都使用了 第三方库，如果工程中出现三方库重复的问题，可将重复文件删除，如果部分接口已经升级或弃用可自行升级、调整。
提供的兼容Demo介绍：
1、Demo集成了初始化sdk、登录、退出登录、IM单聊、联系客服的简单功能，处理了第三方库冲突的问题。
2、pch文件中的appkey等信息需要换成开发者自己的。
3、Demo源码下载地址： https://pan.baidu.com/s/1v1TUl-fqJNLQrtsJfWYGzw
提取码: kukb
0
评论
客服云配置机器人自定义菜单
coinci 发表了文章 • 491 次浏览 • 2019-10-18 16:32
设置机器人自定义菜单
1》管理员模式---智能机器人 新建机器人
2》管理员模式----设置----会话分配规则 渠道指定，添加访客发起会话的渠道（例如APP和网页），全天指定机器人
修改路由规则后，需要在管理员模式--当前会话 手动关闭旧会话，新会话才能重新调度
3》 企业版机器人：管理员模式---智能机器人 点击【机器人管理】，新页面跳转到企业版机器人管理平台
知识管理模块----菜单管理
旧版机器人：管理员模式--智能机器人 点击自定义菜单页签
4》机器人的自定义菜单需要设置为默认回复或者欢迎语才能触发
以下是设置为默认回复：点击蓝色 添加默认回复按钮，选择类型为菜单
以下是配置为机器人的欢迎语
点击蓝色添加按钮，同样选择为菜单类型，选择刚创建的自定义菜单，最后保存（注意设置为机器人欢迎语后:只有网页会生效显示，APP需要单独代码集成，微信和微博不支持机器人欢迎语）
注意：如果新建自定义菜单的时候只新建了菜单名，没有设置菜单项，上图界面是无法点击保存按钮的。需到自定义菜单页面给菜单添加菜单项。
以上是配置好的截图，就可以发起新会话测试了
5》测试：以下是网页测试截图
h5链接在：管理员模式--渠道管理-网站 接入方式 页面 ，点击直接打开h5链接按钮即可
附：企业版机器人基础配置文档：http://docs-ai.easemob.com/cs/preliminary
客服系统旧版机器人文档：http://docs.easemob.com/cs/200 ... %25BA
查看全部
1》管理员模式---智能机器人 新建机器人
2》管理员模式----设置----会话分配规则 渠道指定，添加访客发起会话的渠道（例如APP和网页），全天指定机器人
修改路由规则后，需要在管理员模式--当前会话 手动关闭旧会话，新会话才能重新调度
3》 企业版机器人：管理员模式---智能机器人 点击【机器人管理】，新页面跳转到企业版机器人管理平台
知识管理模块----菜单管理
旧版机器人：管理员模式--智能机器人 点击自定义菜单页签
4》机器人的自定义菜单需要设置为默认回复或者欢迎语才能触发
以下是设置为默认回复：点击蓝色 添加默认回复按钮，选择类型为菜单
以下是配置为机器人的欢迎语
点击蓝色添加按钮，同样选择为菜单类型，选择刚创建的自定义菜单，最后保存（注意设置为机器人欢迎语后:只有网页会生效显示，APP需要单独代码集成，微信和微博不支持机器人欢迎语）
注意：如果新建自定义菜单的时候只新建了菜单名，没有设置菜单项，上图界面是无法点击保存按钮的。需到自定义菜单页面给菜单添加菜单项。
以上是配置好的截图，就可以发起新会话测试了
5》测试：以下是网页测试截图
h5链接在：管理员模式--渠道管理-网站 接入方式 页面 ，点击直接打开h5链接按钮即可
附：企业版机器人基础配置文档：http://docs-ai.easemob.com/cs/preliminary
客服系统旧版机器人文档：http://docs.easemob.com/cs/200 ... %25BA
查看全部
设置机器人自定义菜单
1》管理员模式---智能机器人 新建机器人
2》管理员模式----设置----会话分配规则 渠道指定，添加访客发起会话的渠道（例如APP和网页），全天指定机器人
修改路由规则后，需要在管理员模式--当前会话 手动关闭旧会话，新会话才能重新调度
3》 企业版机器人：管理员模式---智能机器人 点击【机器人管理】，新页面跳转到企业版机器人管理平台
知识管理模块----菜单管理
旧版机器人：管理员模式--智能机器人 点击自定义菜单页签
4》机器人的自定义菜单需要设置为默认回复或者欢迎语才能触发
以下是设置为默认回复：点击蓝色 添加默认回复按钮，选择类型为菜单
以下是配置为机器人的欢迎语
点击蓝色添加按钮，同样选择为菜单类型，选择刚创建的自定义菜单，最后保存（注意设置为机器人欢迎语后:只有网页会生效显示，APP需要单独代码集成，微信和微博不支持机器人欢迎语）
注意：如果新建自定义菜单的时候只新建了菜单名，没有设置菜单项，上图界面是无法点击保存按钮的。需到自定义菜单页面给菜单添加菜单项。
以上是配置好的截图，就可以发起新会话测试了
5》测试：以下是网页测试截图
h5链接在：管理员模式--渠道管理-网站 接入方式 页面 ，点击直接打开h5链接按钮即可
附：企业版机器人基础配置文档：http://docs-ai.easemob.com/cs/preliminary
客服系统旧版机器人文档：http://docs.easemob.com/cs/200 ... %25BA
1》管理员模式---智能机器人 新建机器人
2》管理员模式----设置----会话分配规则 渠道指定，添加访客发起会话的渠道（例如APP和网页），全天指定机器人
修改路由规则后，需要在管理员模式--当前会话 手动关闭旧会话，新会话才能重新调度
3》 企业版机器人：管理员模式---智能机器人 点击【机器人管理】，新页面跳转到企业版机器人管理平台
知识管理模块----菜单管理
旧版机器人：管理员模式--智能机器人 点击自定义菜单页签
4》机器人的自定义菜单需要设置为默认回复或者欢迎语才能触发
以下是设置为默认回复：点击蓝色 添加默认回复按钮，选择类型为菜单
以下是配置为机器人的欢迎语
点击蓝色添加按钮，同样选择为菜单类型，选择刚创建的自定义菜单，最后保存（注意设置为机器人欢迎语后:只有网页会生效显示，APP需要单独代码集成，微信和微博不支持机器人欢迎语）
注意：如果新建自定义菜单的时候只新建了菜单名，没有设置菜单项，上图界面是无法点击保存按钮的。需到自定义菜单页面给菜单添加菜单项。
以上是配置好的截图，就可以发起新会话测试了
5》测试：以下是网页测试截图
h5链接在：管理员模式--渠道管理-网站 接入方式 页面 ，点击直接打开h5链接按钮即可
附：企业版机器人基础配置文档：http://docs-ai.easemob.com/cs/preliminary
客服系统旧版机器人文档：http://docs.easemob.com/cs/200 ... %25BA
0
评论
客服云访客发送订单或者轨迹消息后不展示
coinci 发表了文章 • 401 次浏览 • 2019-10-18 11:58
访客端发送订单或者轨迹消息后不显示
默认是发送后访客端删除本条消息，可以修改
Android
ChatrowOrder 查找removeMessage
网页修改
管理员模式--设置--系统开关 访客端同步展示轨迹消息 开关打开
查看全部
默认是发送后访客端删除本条消息，可以修改
Android
ChatrowOrder 查找removeMessage
网页修改
管理员模式--设置--系统开关 访客端同步展示轨迹消息 开关打开
查看全部
访客端发送订单或者轨迹消息后不显示
默认是发送后访客端删除本条消息，可以修改
Android
ChatrowOrder 查找removeMessage
网页修改
管理员模式--设置--系统开关 访客端同步展示轨迹消息 开关打开
默认是发送后访客端删除本条消息，可以修改
Android
ChatrowOrder 查找removeMessage
网页修改
管理员模式--设置--系统开关 访客端同步展示轨迹消息 开关打开
7
回复
Android 会话列表无数据问题
lizg 回复了问题 • 2 人关注 • 1108 次浏览 • 2019-10-17 17:08
1
回复
小程序SDK：WebIM.conn.joinGroup 申请加群报错
lizg 回复了问题 • 2 人关注 • 1031 次浏览 • 2019-10-17 16:53
0
评论
客服云自定义角色权限
coinci 发表了文章 • 417 次浏览 • 2019-10-17 14:56
****1.新建自定义角色
管理员模式----设置---权限管理 页面右上角 添加角色
需要填写角色名称，角色权限 分为两大类：管理员模式 和客服模式
这两种模式的展开项分别对应两种模式下的所有功能模块（按需勾选）
以下操作以新建一个角色权限为：客服模式下所有功能，管理员模式下只有质检功能 为例：
**第一:客服模式根目录直接勾选
**第二：管理员模式 点击 展示所有功能模块，只需要勾选 质检功能的3个复选框
同时可以规则新角色的数据权限：租户或者客服
**第三：最后操作保存（tips：创建的自定义角色不能超过20个）
****2.给客服修改权限
管理员模式---成员管理--客服
进入客服列表页面，选择要修改的客服，选项 一列点击编辑按钮
弹出客服信息修改对话框，滑动到底部
修改角色，最后保存
客服如果是登录状态，会自动给客服发送通知，客服需重新登录系统，新角色权限可以生效。 查看全部
管理员模式----设置---权限管理 页面右上角 添加角色
需要填写角色名称，角色权限 分为两大类：管理员模式 和客服模式
这两种模式的展开项分别对应两种模式下的所有功能模块（按需勾选）
以下操作以新建一个角色权限为：客服模式下所有功能，管理员模式下只有质检功能 为例：
**第一:客服模式根目录直接勾选
**第二：管理员模式 点击 展示所有功能模块，只需要勾选 质检功能的3个复选框
同时可以规则新角色的数据权限：租户或者客服
**第三：最后操作保存（tips：创建的自定义角色不能超过20个）
****2.给客服修改权限
管理员模式---成员管理--客服
进入客服列表页面，选择要修改的客服，选项 一列点击编辑按钮
弹出客服信息修改对话框，滑动到底部
修改角色，最后保存
客服如果是登录状态，会自动给客服发送通知，客服需重新登录系统，新角色权限可以生效。 查看全部
****1.新建自定义角色
管理员模式----设置---权限管理 页面右上角 添加角色
需要填写角色名称，角色权限 分为两大类：管理员模式 和客服模式
这两种模式的展开项分别对应两种模式下的所有功能模块（按需勾选）
以下操作以新建一个角色权限为：客服模式下所有功能，管理员模式下只有质检功能 为例：
**第一:客服模式根目录直接勾选
**第二：管理员模式 点击 展示所有功能模块，只需要勾选 质检功能的3个复选框
同时可以规则新角色的数据权限：租户或者客服
**第三：最后操作保存（tips：创建的自定义角色不能超过20个）
****2.给客服修改权限
管理员模式---成员管理--客服
进入客服列表页面，选择要修改的客服，选项 一列点击编辑按钮
弹出客服信息修改对话框，滑动到底部
修改角色，最后保存
客服如果是登录状态，会自动给客服发送通知，客服需重新登录系统，新角色权限可以生效。
管理员模式----设置---权限管理 页面右上角 添加角色
需要填写角色名称，角色权限 分为两大类：管理员模式 和客服模式
这两种模式的展开项分别对应两种模式下的所有功能模块（按需勾选）
以下操作以新建一个角色权限为：客服模式下所有功能，管理员模式下只有质检功能 为例：
**第一:客服模式根目录直接勾选
**第二：管理员模式 点击 展示所有功能模块，只需要勾选 质检功能的3个复选框
同时可以规则新角色的数据权限：租户或者客服
**第三：最后操作保存（tips：创建的自定义角色不能超过20个）
****2.给客服修改权限
管理员模式---成员管理--客服
进入客服列表页面，选择要修改的客服，选项 一列点击编辑按钮
弹出客服信息修改对话框，滑动到底部
修改角色，最后保存
客服如果是登录状态，会自动给客服发送通知，客服需重新登录系统，新角色权限可以生效。
