传统游戏项目一般使用TCP协议进行通信，得益于它的稳定和可靠，不过在网络不稳定的情况下，会出现丢包严重。

不过近期有不少基于UDP的应用层协议，声称对UDP的不可靠进行了改造，这意味着我们既可以享受网络层提供稳定可靠的服务，又可以享受它的速度。

KCP就是这样的一个协议

不过网上说的再天花乱坠，我们也得亲自调研，分析源码和它的机制，并测试它的性能，是否满足项目上线要求。本文从C版本的源码入手理解KCP的机制，再研究各种Java版本的实现

一、KCP协议

原版源码（C代码）： 
https://github.com/skywind3000/kcp

基于底层协议（一般是UDP）之上，完全在应用层实现类TCP的可靠机制（快速重传，拥塞控制等）

二、KCP特性

KCP实现以下特性，也可参考github中README中对KCP的定义

三、KCP报文

1. 报文解析源码

源码中对报文解析部分代码如下

data = ikcp_decode32u(data, &conv); if (conv != kcp->conv) return -1; data = ikcp_decode8u(data, &cmd); data = ikcp_decode8u(data, &frg); data = ikcp_decode16u(data, &wnd); data = ikcp_decode32u(data, &ts); data = ikcp_decode32u(data, &sn); data = ikcp_decode32u(data, &una); data = ikcp_decode32u(data, &len);

2. 报文定义

报文中标识的定义

3. 消息类型

KCP报文的四种消息类型

const IUINT32 IKCP_CMD_PUSH = 81; // cmd: push data: 推送数据 const IUINT32 IKCP_CMD_ACK  = 82; // cmd: ack: 对推送数据的确认 const IUINT32 IKCP_CMD_WASK = 83; // cmd: window probe (ask): 询问窗口大小 const IUINT32 IKCP_CMD_WINS = 84; // cmd: window size (tell): 回复窗口大小 

1. 报文结构

四、源码解析

在网络四层模型中，KCP和TCP/UDP（传输层），IP（网络层）等协议有着本质上区别，理论上KCP是属于应用层协议。

KCP并不提供协议实际收发处理，它只是在传输层只上对消息和链接的一层中间管理。

在KCP的源码中，它仅仅包含ikcp.c和ikcp.h两个文件，仅提供KCP的数据管理和数据接口，而用户需要在应用层进行KCP的调度

1. 结构体定义

KCP分包结构KCP对象结构体定义

struct IKCPSEG { struct IQUEUEHEAD node; IUINT32 conv; //用来标记这个seg属于哪个kcp IUINT32 cmd;//这个包的指令是： // 数据 ack 询问/应答窗口大小 IUINT32 frg; //分包时，分包的序号，0为终结 IUINT32 wnd;//发送这个seg的这个端的 窗口大小--> 远端的接收窗口大小 IUINT32 ts; //我不知道为什么要用时间轴，这个都1秒，有什么用 ?? IUINT32 sn;//相当于tcp的ack IUINT32 una;//una 远端等待接收的一个序号 IUINT32 len; //data的长度 IUINT32 resendts;//重发的时间轴 IUINT32 rto;//等于发送端kcp的 rx_rto->由 计算得来 IUINT32 fastack;//ack跳过的次数，用于快速重传 IUINT32 xmit;// fastack resend次数 char data[1];//当malloc时，只需要  malloc(sizeof(IKCPSEG)+datalen) 则，data长=数据长度+1 刚好用来放0 }; struct IKCPCB { //会话ID,最大传输单元,最大分片大小，状态   mss=mtu-sizeof(IKCPSEG) IUINT32 conv, mtu, mss, state; //第一个未接收到的包，待发送的包(可以认为是tcp的ack自增)，接收消息的序号-> 用来赋seg的una值 IUINT32 snd_una, snd_nxt, rcv_nxt; //前两个不知道干嘛  拥塞窗口的阈值 用来控制cwnd值变化的 IUINT32 ts_recent, ts_lastack, ssthresh; //这几个变量是用来更新rto的 // rx_rttval 接收ack的浮动值 // rx_srtt 接收ack的平滑值 // rx_rto 计算出来的rto // rx_minrto 最小rto IINT32 rx_rttval, rx_srtt, rx_rto, rx_minrto; //发送队列的窗口大小 //接收队列的窗口大小 //远端的接收队列的窗口大小 //窗口大小 //probe 用来二进制标记 IUINT32 snd_wnd, rcv_wnd, rmt_wnd, cwnd, probe; //时间轴 时间间隔 下一次flush的时间  xmit发射多少次？ 看不到有什么地方用到 IUINT32 current, interval, ts_flush, xmit; //接收到的数据seg个数 //需要发送的seg个数 IUINT32 nrcv_buf, nsnd_buf; //接收队列的数据 seg个数 //发送队列的数据 seg个数 IUINT32 nrcv_que, nsnd_que; //是否为nodelay模式:如果开启，rto计算范围更小 //updated 在调用flush时，有没有调用过update IUINT32 nodelay, updated; //请求访问窗口的时间相关 当远程端口大小为0时 IUINT32 ts_probe, probe_wait;
    IUINT32 dead_link, incr; //发送队列 struct IQUEUEHEAD snd_queue; //接收队列 struct IQUEUEHEAD rcv_queue; //待发送队列 struct IQUEUEHEAD snd_buf; //待接收队列 struct IQUEUEHEAD rcv_buf; //用来缓存自己接收到了多少个ack IUINT32 *acklist;
    IUINT32 ackcount;
    IUINT32 ackblock; //用户信息 void *user; //好像就用来操作数据的中转站 char *buffer; //快速重传的阈值 int fastresend; //快速重传的上限 int fastlimit; //是否无视重传等其它设置窗口 //steam模式的话，会将几个小包合并成大包 int nocwnd, stream; int logmask; int (*output)(const char *buf, int len, struct IKCPCB *kcp, void *user); void (*writelog)(const char *log, struct IKCPCB *kcp, void *user);
};

2. 接口分析

分析C源码，KCP作为中间管理层，主要提供以下接口

//--------------------------------------------------------------------- // interface //--------------------------------------------------------------------- // create a new kcp control object, 'conv' must equal in two endpoint // from the same connection. 'user' will be passed to the output callback // output callback can be setup like this: 'kcp->output = my_udp_output' // 创建kcp对象，conv必须在两个端之间相同，user会被传递到output回调， // output回调这样设置：kcp->output = my_udp_output ikcpcb* ikcp_create(IUINT32 conv, void *user); // release kcp control object // 释放kcp对象 void ikcp_release(ikcpcb *kcp); // set output callback, which will be invoked by kcp // 设置kcp调用的output回调 void ikcp_setoutput(ikcpcb *kcp, int (*output)(const char *buf, int len, 
   ikcpcb *kcp, void *user)); // user/upper level recv: returns size, returns below zero for EAGAIN // 用户层/上层 接收消息：返回接收长度，数据读取错误返回值小于0 int ikcp_recv(ikcpcb *kcp, char *buffer, int len); // user/upper level send, returns below zero for error // 用户层/上层 发送消息，错误返回值小于0 int ikcp_send(ikcpcb *kcp, const char *buffer, int len); // update state (call it repeatedly, every 10ms-100ms), or you can ask  // ikcp_check when to call it again (without ikcp_input/_send calling). // 'current' - current timestamp in millisec.  // 更新状态（每10ms-100ms调用一次），或者你可以通过调用ikcp_check， // 来得知什么时候再次调用(不调用ikcp_input/_send) // current - 当前时间戳（毫秒） void ikcp_update(ikcpcb *kcp, IUINT32 current); // Determine when should you invoke ikcp_update: // returns when you should invoke ikcp_update in millisec, if there  // is no ikcp_input/_send calling. you can call ikcp_update in that // time, instead of call update repeatly. // Important to reduce unnacessary ikcp_update invoking. use it to  // schedule ikcp_update (eg. implementing an epoll-like mechanism,  // or optimize ikcp_update when handling massive kcp connections) // 决定你什么时候调用ikcp_update // 返回你多少毫秒后应该调用ikcp_update，如果没有ikcp_input/_send调用，你可以在那个时间 // 调用ikcp_updates来代替自己驱动update调用 // 用于减少不必要的ikcp_update调用。用这个来驱动ikcp_update（比如：实现类epoll的机制， // 或者优化处理大量kcp连接时的ikcp_update调用） IUINT32 ikcp_check(const ikcpcb *kcp, IUINT32 current); // when you received a low level packet (eg. UDP packet), call it // 接收下层数据包（比如：UDP数据包）时调用 int ikcp_input(ikcpcb *kcp, const char *data, long size); // flush pending data // 刷新数据 void ikcp_flush(ikcpcb *kcp); // check the size of next message in the recv queue // 检测接收队列里下条消息的长度 int ikcp_peeksize(const ikcpcb *kcp); // change MTU size, default is 1400 // 修改MTU长度，默认1400 int ikcp_setmtu(ikcpcb *kcp, int mtu); // set maximum window size: sndwnd=32, rcvwnd=32 by default // 设置最大窗口大小，默认值：sndwnd=32, rcvwnd=32 int ikcp_wndsize(ikcpcb *kcp, int sndwnd, int rcvwnd); // get how many packet is waiting to be sent // 获取准备发送的数据包 int ikcp_waitsnd(const ikcpcb *kcp); // fastest: ikcp_nodelay(kcp, 1, 20, 2, 1) // nodelay: 0:disable(default), 1:enable // interval: internal update timer interval in millisec, default is 100ms  // resend: 0:disable fast resend(default), 1:enable fast resend // nc: 0:normal congestion control(default), 1:disable congestion control // 快速设置：ikcp_nodelay(kcp, 1, 20, 2, 1) // nodelay：0：使用（默认），1：使用 // interval：update时间（毫秒），默认100ms // resend：0:不适用快速重发(默认), 其他：自己设置值，若设置为2（则2次ACK跨越将会直接重传） // nc：0:正常拥塞控制(默认), 1:不适用拥塞控制 int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc); void ikcp_log(ikcpcb *kcp, int mask, const char *fmt, ...); // setup allocator // 设置kcp allocator void ikcp_allocator(void* (*new_malloc)(size_t), void (*new_free)(void*)); // read conv // 获取conv IUINT32 ikcp_getconv(const void *ptr);

3. 调度逻辑

KCP关键接口：

• 更新（上层驱动KCP状态更新） 
  ikcp_update：kcp状态更新接口，需要上层进行调度，判断flush时间，满足条件调用ikcp_flush刷新数据，同时也负责对收到数据的kcp端回复ACK消息
• 发送 
  ikcp_send -> ikcp_update -> ikcp_output ikcp_send：上层调用发送接口，把数据根据mss值进行分片，设置分包编号，放到snd_queue队尾 ikcp_flush：发送数据接口，根据对端窗口大小，拷贝snd_queue的数据到snd_buf，遍历snd_buf，满足条件则调用output回调（调用网络层的发送）
• 接收 
  ikcp_input -> ikcp_update -> ikcp_recv ikcp_input：解析上层输入数据，拷贝rcv_buf到rcv_queue ikcp_recv：数据接收接口，上层从rcv_queue中复制数据到网络层buffer

五、Java版本

目前github上有几个高star的java版本实现，选取最高的三个进行分析

1.https://github.com/szhnet/kcp-netty.git（star:212）

实现原理：

1.KCP逻辑是源码的Java翻译版（一模一样）

2.UkcpServerChannel继承ServerChannel，UkcpServerBootStrap

3.用Boss线程 EventLoopGroup的read事件来驱动KCP逻辑

优点：使用Netty的Boss线程Read事件来驱动KCP，不用while(true)的驱动；使用简单，只需使用指定的ServerChannel和ServerBootStrap来启动Netty

缺点：无明显缺点

2.https://github.com/beykery/jkcp.git（star:172）

实现原理：

1.KCP逻辑是源码的Java翻译版（一模一样）

2.启动指定线程数的KcpThread自定义IO线程池，进行KCP逻辑调度

3.Netty读消息时抛到KcpThread自定义IO线程

// 通过hash选择IO线程处理
InetSocketAddress sender = dp.sender();
int hash = sender.hashCode(); hash = hash < 0 ? -hash : hash;
this.workers[hash % workers.length].input(dp);

优点：代码简单明了，容易理解，核心是翻译版源码，外壳套的是Netty+自定义IO线程池

缺点：IO线程池会while(true)的调用KCP的update

3.https://github.com/l42111996/java-Kcp.git（star:187）

实现原理：

1.KCP逻辑是源码的Java翻译版（一模一样）

2.Netty读消息时，扔到定时器，1ms后，抛出任务到自定义IO线程

优点：拥有1的全部优点，也在Netty的读消息，把消息抛到定时器去调用KCP的逻辑，避免了2的无意义的while(true)，同时实现功能更全，有上线项目验证（据作者描述）

缺点：Netty相关逻辑完全封装起来，不能修改任何Netty参数（不过源码中对Netty的参数已配置的很好了）

目前看来，第三种实现（ 
https://github.com/l42111996/java-Kcp.git）是最理想的方式

如果大家感兴趣，后边会对第三种实现进行详细的源码分析