TCP 协议灵魂问题，巩固你的网路底层基础

先亮出这篇文章的思惟导图

TCP 做为传输层的协议，是一个软件工程师素养的体现，也是面试中常常被问到的知识点。在此，我将 TCP 核心的一些问题梳理了一下，但愿能帮到各位。

001. 能不能说一说 TCP 和 UDP 的区别？

首先归纳一下基本的区别:

TCP是一个面向链接的、可靠的、基于字节流的传输层协议。

而UDP是一个面向无链接的传输层协议。(就这么简单，其它TCP的特性也就没有了)。

具体来分析，和 UDP 相比，TCP 有三大核心特性:

1. 面向链接。所谓的链接，指的是客户端和服务器的链接，在双方互相通讯以前，TCP 须要三次握手创建链接，而 UDP 没有相应创建链接的过程。
2. 可靠性。TCP 花了很是多的功夫保证链接的可靠，这个可靠性体如今哪些方面呢？一个是有状态，另外一个是可控制。

TCP 会精准记录哪些数据发送了，哪些数据被对方接收了，哪些没有被接收到，并且保证数据包按序到达，不容许半点差错。这是有状态。

当意识到丢包了或者网络环境不佳，TCP 会根据具体状况调整本身的行为，控制本身的发送速度或者重发。这是可控制。

相应的，UDP 就是无状态, 不可控的。

1. 面向字节流。UDP 的数据传输是基于数据报的，这是由于仅仅只是继承了 IP 层的特性，而 TCP 为了维护状态，将一个个 IP 包变成了字节流。

002: 说说 TCP 三次握手的过程？为何是三次而不是两次、四次？

恋爱模拟

以谈恋爱为例，两我的可以在一块儿最重要的事情是首先确认各自爱和被爱的能力。接下来咱们以此来模拟三次握手的过程。

第一次:

男: 我爱你。

女方收到。

由此证实男方拥有爱的能力。

第二次:

女: 我收到了你的爱，我也爱你。

男方收到。

OK，如今的状况说明，女方拥有爱和被爱的能力。

第三次:

男: 我收到了你的爱。

女方收到。

如今可以保证男方具有被爱的能力。

由此完整地确认了双方爱和被爱的能力，两人开始一段甜蜜的爱情。

真实握手

固然刚刚那段属于扯淡，不表明本人价值观，目的是让你们理解整个握手过程的意义，由于两个过程很是类似。对应到 TCP 的三次握手，也是须要确认双方的两样能力: 发送的能力和接收的能力。因而便会有下面的三次握手的过程:

从最开始双方都处于CLOSED状态。而后服务端开始监听某个端口，进入了LISTEN状态。

而后客户端主动发起链接，发送 SYN , 本身变成了SYN-SENT状态。

服务端接收到，返回SYN和ACK(对应客户端发来的SYN)，本身变成了SYN-REVD。

以后客户端再发送ACK给服务端，本身变成了ESTABLISHED状态；服务端收到ACK以后，也变成了ESTABLISHED状态。

另外须要提醒你注意的是，从图中能够看出，SYN 是须要消耗一个序列号的，下次发送对应的 ACK 序列号要加1，为何呢？只须要记住一个规则:

凡是须要对端确认的，必定消耗TCP报文的序列号。

SYN 须要对端的确认， 而 ACK 并不须要，所以 SYN 消耗一个序列号而 ACK 不须要。

为何不是两次？

根本缘由: 没法确认客户端的接收能力。

分析以下:

若是是两次，你如今发了 SYN 报文想握手，可是这个包滞留在了当前的网络中迟迟没有到达，TCP 觉得这是丢了包，因而重传，两次握手创建好了链接。

看似没有问题，可是链接关闭后，若是这个滞留在网路中的包到达了服务端呢？这时候因为是两次握手，服务端只要接收到而后发送相应的数据包，就默认创建链接，可是如今客户端已经断开了。

看到问题的吧，这就带来了链接资源的浪费。

为何不是四次？

三次握手的目的是确认双方发送和接收的能力，那四次握手能够嘛？

固然能够，100 次均可以。但为了解决问题，三次就足够了，再多用处就不大了。

三次握手过程当中能够携带数据么？

第三次握手的时候，能够携带。前两次握手不能携带数据。

若是前两次握手可以携带数据，那么一旦有人想攻击服务器，那么他只须要在第一次握手中的 SYN 报文中放大量数据，那么服务器势必会消耗更多的时间和内存空间去处理这些数据，增大了服务器被攻击的风险。

第三次握手的时候，客户端已经处于ESTABLISHED状态，而且已经可以确认服务器的接收、发送能力正常，这个时候相对安全了，能够携带数据。

同时打开会怎样？

若是双方同时发 SYN报文，状态变化会是怎样的呢？

这是一个可能会发生的状况。

状态变迁以下:

在发送方给接收方发SYN报文的同时，接收方也给发送方发SYN报文，两我的刚上了!

发完SYN，二者的状态都变为SYN-SENT。

在各自收到对方的SYN后，二者状态都变为SYN-REVD。

接着会回复对应的ACK + SYN，这个报文在对方接收以后，二者状态一块儿变为ESTABLISHED。

这就是同时打开状况下的状态变迁。

003: 说说 TCP 四次挥手的过程

过程拆解

刚开始双方处于ESTABLISHED状态。

客户端要断开了，向服务器发送 FIN 报文，在 TCP 报文中的位置以下图:

发送后客户端变成了FIN-WAIT-1状态。注意, 这时候客户端同时也变成了half-close(半关闭)状态，即没法向服务端发送报文，只能接收。

服务端接收后向客户端确认，变成了CLOSED-WAIT状态。

客户端接收到了服务端的确认，变成了FIN-WAIT2状态。

随后，服务端向客户端发送FIN，本身进入LAST-ACK状态，

客户端收到服务端发来的FIN后，本身变成了TIME-WAIT状态，而后发送 ACK 给服务端。

注意了，这个时候，客户端须要等待足够长的时间，具体来讲，是 2 个 MSL(Maximum Segment Lifetime，报文最大生存时间), 在这段时间内若是客户端没有收到服务端的重发请求，那么表示 ACK 成功到达，挥手结束，不然客户端重发 ACK。

等待2MSL的意义

若是不等待会怎样？

若是不等待，客户端直接跑路，当服务端还有不少数据包要给客户端发，且还在路上的时候，若客户端的端口此时恰好被新的应用占用，那么就接收到了无用数据包，形成数据包混乱。因此，最保险的作法是等服务器发来的数据包都死翘翘再启动新的应用。

那，照这样说一个 MSL 不就不够了吗，为何要等待 2 MSL?

• 1 个 MSL 确保四次挥手中主动关闭方最后的 ACK 报文最终能达到对端
• 1 个 MSL 确保对端没有收到 ACK 重传的 FIN 报文能够到达

这就是等待 2MSL 的意义。

为何是四次挥手而不是三次？

由于服务端在接收到FIN, 每每不会当即返回FIN, 必须等到服务端全部的报文都发送完毕了，才能发FIN。所以先发一个ACK表示已经收到客户端的FIN，延迟一段时间才发FIN。这就形成了四次挥手。

若是是三次挥手会有什么问题？

等于说服务端将ACK和FIN的发送合并为一次挥手，这个时候长时间的延迟可能会致使客户端误觉得FIN没有到达客户端，从而让客户端不断的重发FIN。

同时关闭会怎样？

若是客户端和服务端同时发送 FIN ，状态会如何变化？如图所示:

004: 说说半链接队列和 SYN Flood 攻击的关系

三次握手前，服务端的状态从CLOSED变为LISTEN, 同时在内部建立了两个队列：半链接队列和全链接队列，即SYN队列和ACCEPT队列。

半链接队列

当客户端发送SYN到服务端，服务端收到之后回复ACK和SYN，状态由LISTEN变为SYN_RCVD，此时这个链接就被推入了SYN队列，也就是半链接队列。

全链接队列

当客户端返回ACK, 服务端接收后，三次握手完成。这个时候链接等待被具体的应用取走，在被取走以前，它会被推入另一个 TCP 维护的队列，也就是全链接队列(Accept Queue)。

SYN Flood 攻击原理

SYN Flood 属于典型的 DoS/DDoS 攻击。其攻击的原理很简单，就是用客户端在短期内伪造大量不存在的 IP 地址，并向服务端疯狂发送SYN。对于服务端而言，会产生两个危险的后果:

1. 处理大量的SYN包并返回对应ACK, 势必有大量链接处于SYN_RCVD状态，从而占满整个半链接队列，没法处理正常的请求。
2. 因为是不存在的 IP，服务端长时间收不到客户端的ACK，会致使服务端不断重发数据，直到耗尽服务端的资源。

如何应对 SYN Flood 攻击？

1. 增长 SYN 链接，也就是增长半链接队列的容量。
2. 减小 SYN + ACK 重试次数，避免大量的超时重发。
3. 利用 SYN Cookie 技术，在服务端接收到SYN后不当即分配链接资源，而是根据这个SYN计算出一个Cookie，连同第二次握手回复给客户端，在客户端回复ACK的时候带上这个Cookie值，服务端验证 Cookie 合法以后才分配链接资源。

005: 介绍一下 TCP 报文头部的字段

报文头部结构以下(单位为字节):

请你们牢记这张图！

源端口、目标端口

如何标识惟一标识一个链接？答案是 TCP 链接的四元组——源 IP、源端口、目标 IP 和目标端口。

那 TCP 报文怎么没有源 IP 和目标 IP 呢？这是由于在 IP 层就已经处理了 IP 。TCP 只须要记录二者的端口便可。

序列号

即Sequence number, 指的是本报文段第一个字节的序列号。

从图中能够看出，序列号是一个长为 4 个字节，也就是 32 位的无符号整数，表示范围为 0 ~ 2^32 - 1。若是到达最大值了后就循环到0。

序列号在 TCP 通讯的过程当中有两个做用:

1. 在 SYN 报文中交换彼此的初始序列号。
2. 保证数据包按正确的顺序组装。

ISN

即Initial Sequence Number（初始序列号）,在三次握手的过程中，双方会用过SYN报文来交换彼此的 ISN。

ISN 并非一个固定的值，而是每 4 ms 加一，溢出则回到 0，这个算法使得猜想 ISN 变得很困难。那为何要这么作？

若是 ISN 被攻击者预测到，要知道源 IP 和源端口号都是很容易伪造的，当攻击者猜想 ISN 以后，直接伪造一个 RST 后，就能够强制链接关闭的，这是很是危险的。

而动态增加的 ISN 大大提升了猜想 ISN 的难度。

确认号

即ACK(Acknowledgment number)。用来告知对方下一个指望接收的序列号，小于ACK的全部字节已经所有收到。

标记位

常见的标记位有SYN,ACK,FIN,RST,PSH。

SYN 和 ACK 已经在上文说过，后三个解释以下: FIN：即 Finish，表示发送方准备断开链接。

RST：即 Reset，用来强制断开链接。

PSH：即 Push, 告知对方这些数据包收到后应该立刻交给上层的应用，不能缓存。

窗口大小

占用两个字节，也就是 16 位，但其实是不够用的。所以 TCP 引入了窗口缩放的选项，做为窗口缩放的比例因子，这个比例因子的范围在 0 ~ 14，比例因子能够将窗口的值扩大为原来的 2 ^ n 次方。

校验和

占用两个字节，防止传输过程当中数据包有损坏，若是遇到校验和有差错的报文，TCP 直接丢弃之，等待重传。

可选项

可选项的格式以下:

经常使用的可选项有如下几个:

• TimeStamp: TCP 时间戳，后面详细介绍。
• MSS: 指的是 TCP 容许的从对方接收的最大报文段。
• SACK: 选择确认选项。
• Window Scale：窗口缩放选项。

006: 说说 TCP 快速打开的原理(TFO)

第一节讲了 TCP 三次握手，可能有人会说，每次都三次握手好麻烦呀！能不能优化一点？

能够啊。今天来讲说这个优化后的 TCP 握手流程，也就是 TCP 快速打开(TCP Fast Open, 即TFO)的原理。

优化的过程是这样的，还记得咱们说 SYN Flood 攻击时提到的 SYN Cookie 吗？这个 Cookie 可不是浏览器的Cookie, 用它一样能够实现 TFO。

TFO 流程

首轮三次握手

首先客户端发送SYN给服务端，服务端接收到。

注意哦！如今服务端不是马上回复 SYN + ACK，而是经过计算获得一个SYN Cookie, 将这个Cookie放到 TCP 报文的 Fast Open选项中，而后才给客户端返回。

客户端拿到这个 Cookie 的值缓存下来。后面正常完成三次握手。

首轮三次握手就是这样的流程。然后面的三次握手就不同啦！

后面的三次握手

在后面的三次握手中，客户端会将以前缓存的 Cookie、SYN 和HTTP请求(是的，你没看错)发送给服务端，服务端验证了 Cookie 的合法性，若是不合法直接丢弃；若是是合法的，那么就正常返回SYN + ACK。

重点来了，如今服务端能向客户端发 HTTP 响应了！这是最显著的改变，三次握手还没创建，仅仅验证了 Cookie 的合法性，就能够返回 HTTP 响应了。

固然，客户端的ACK还得正常传过来，否则怎么叫三次握手嘛。

流程以下:

注意: 客户端最后握手的 ACK 不必定要等到服务端的 HTTP 响应到达才发送，两个过程没有任何关系。

TFO 的优点

TFO 的优点并不在与首轮三次握手，而在于后面的握手，在拿到客户端的 Cookie 并验证经过之后，能够直接返回 HTTP 响应，充分利用了1 个RTT(Round-Trip Time，往返时延)的时间提早进行数据传输，积累起来仍是一个比较大的优点。

007: 能不能说说TCP报文中时间戳的做用？

timestamp是 TCP 报文首部的一个可选项，一共占 10 个字节，格式以下:

kind(1 字节) + length(1 字节) + info(8 个字节)

其中 kind = 8， length = 10， info 有两部分构成: timestamp和timestamp echo，各占 4 个字节。

那么这些字段都是干吗的呢？它们用来解决那些问题？

接下来咱们就来一一梳理，TCP 的时间戳主要解决两大问题:

• 计算往返时延 RTT(Round-Trip Time)
• 防止序列号的回绕问题

计算往返时延 RTT

在没有时间戳的时候，计算 RTT 会遇到的问题以下图所示:

若是以第一次发包为开始时间的话，就会出现左图的问题，RTT 明显偏大，开始时间应该采用第二次的；

若是以第二次发包为开始时间的话，就会致使右图的问题，RTT 明显偏小，开始时间应该采用第一次发包的。

实际上不管开始时间以第一次发包仍是第二次发包为准，都是不许确的。

那这个时候引入时间戳就很好的解决了这个问题。

好比如今 a 向 b 发送一个报文 s1，b 向 a 回复一个含 ACK 的报文 s2 那么：

• step 1: a 向 b 发送的时候，timestamp 中存放的内容就是 a 主机发送时的内核时刻 ta1。
• step 2: b 向 a 回复 s2 报文的时候，timestamp 中存放的是 b 主机的时刻 tb, timestamp echo字段为从 s1 报文中解析出来的 ta1。
• step 3: a 收到 b 的 s2 报文以后，此时 a 主机的内核时刻是 ta2, 而在 s2 报文中的 timestamp echo 选项中能够获得 ta1, 也就是 s2 对应的报文最初的发送时刻。而后直接采用 ta2 - ta1 就获得了 RTT 的值。

防止序列号回绕问题

如今咱们来模拟一下这个问题。

序列号的范围实际上是在0 ~ 2 ^ 32 - 1, 为了方便演示，咱们缩小一下这个区间，假设范围是 0 ~ 4，那么到达 4 的时候会回到 0。

假设在第 6 次的时候，以前还滞留在网路中的包回来了，那么就有两个序列号为1 ~ 2的数据包了，怎么区分谁是谁呢？这个时候就产生了序列号回绕的问题。

那么用 timestamp 就能很好地解决这个问题，由于每次发包的时候都是将发包机器当时的内核时间记录在报文中，那么两次发包序列号即便相同，时间戳也不可能相同，这样就可以区分开两个数据包了。

008: TCP 的超时重传时间是如何计算的？

TCP 具备超时重传机制，即间隔一段时间没有等到数据包的回复时，重传这个数据包。

那么这个重传间隔是如何来计算的呢？

今天咱们就来讨论一下这个问题。

这个重传间隔也叫作超时重传时间(Retransmission TimeOut, 简称RTO)，它的计算跟上一节提到的 RTT 密切相关。这里咱们将介绍两种主要的方法，一个是经典方法，一个是标准方法。

经典方法

经典方法引入了一个新的概念——SRTT(Smoothed round trip time，即平滑往返时间)，没产生一次新的 RTT. 就根据必定的算法对 SRTT 进行更新，具体而言，计算方式以下(SRTT 初始值为0):

SRTT = (α SRTT) + ((1 - α) RTT)

其中，α 是平滑因子，建议值是0.8，范围是0.8 ~ 0.9。

拿到 SRTT，咱们就能够计算 RTO 的值了:

RTO = min(ubound, max(lbound, β * SRTT))

β 是加权因子，通常为1.3 ~ 2.0， lbound 是下界，ubound 是上界。

其实这个算法过程仍是很简单的，可是也存在必定的局限，就是在 RTT 稳定的地方表现还能够，而在 RTT 变化较大的地方就不行了，由于平滑因子 α 的范围是0.8 ~ 0.9, RTT 对于 RTO 的影响过小。

标准方法

为了解决经典方法对于 RTT 变化不敏感的问题，后面又引出了标准方法，也叫Jacobson / Karels 算法。

一共有三步。

第一步: 计算SRTT，公式以下:

SRTT = (1 - α) SRTT + α RTT

注意这个时候的 α跟经典方法中的α取值不同了，建议值是1/8，也就是0.125。

第二步: 计算RTTVAR(round-trip time variation)这个中间变量。

RTTVAR = (1 - β) RTTVAR + β (|RTT - SRTT|)

β 建议值为 0.25。这个值是这个算法中出彩的地方，也就是说，它记录了最新的 RTT 与当前 SRTT 之间的差值，给咱们在后续感知到 RTT 的变化提供了抓手。

第三步: 计算最终的RTO:

RTO = µ SRTT + ∂ RTTVAR

µ建议值取1, ∂建议值取4。

这个公式在 SRTT 的基础上加上了最新 RTT 与它的偏移，从而很好的感知了 RTT 的变化，这种算法下，RTO 与 RTT 变化的差值关系更加密切。

009: 能不能说一说 TCP 的流量控制？

对于发送端和接收端而言，TCP 须要把发送的数据放到发送缓存区, 将接收的数据放到接收缓存区。

而流量控制索要作的事情，就是在经过接收缓存区的大小，控制发送端的发送。若是对方的接收缓存区满了，就不能再继续发送了。

要具体理解流量控制，首先须要了解滑动窗口的概念。

TCP 滑动窗口

TCP 滑动窗口分为两种: 发送窗口和接收窗口。

发送窗口

发送端的滑动窗口结构以下:

其中包含四大部分:

• 已发送且已确认
• 已发送但未确认
• 未发送但能够发送
• 未发送也不能够发送

其中有一些重要的概念，我标注在图中:

发送窗口就是图中被框住的范围。SND 即send, WND 即window, UNA 即unacknowledged, 表示未被确认，NXT 即next, 表示下一个发送的位置。

接收窗口

接收端的窗口结构以下:

REV 即 receive，NXT 表示下一个接收的位置，WND 表示接收窗口大小。

流量控制过程

这里咱们不用太复杂的例子，以一个最简单的来回来模拟一下流量控制的过程，方便你们理解。

首先双方三次握手，初始化各自的窗口大小，均为 200 个字节。

假如当前发送端给接收端发送 100 个字节，那么此时对于发送端而言，SND.NXT 固然要右移 100 个字节，也就是说当前的可用窗口减小了 100 个字节，这很好理解。

如今这 100 个到达了接收端，被放到接收端的缓冲队列中。不过此时因为大量负载的缘由，接收端处理不了这么多字节，只能处理 40 个字节，剩下的 60 个字节被留在了缓冲队列中。

注意了，此时接收端的状况是处理能力不够用啦，你发送端给我少发点，因此此时接收端的接收窗口应该缩小，具体来讲，缩小 60 个字节，由 200 个字节变成了 140 字节，由于缓冲队列还有 60 个字节没被应用拿走。

所以，接收端会在 ACK 的报文首部带上缩小后的滑动窗口 140 字节，发送端对应地调整发送窗口的大小为 140 个字节。

此时对于发送端而言，已经发送且确认的部分增长 40 字节，也就是 SND.UNA 右移 40 个字节，同时发送窗口缩小为 140 个字节。

这也就是流量控制的过程。尽管回合再多，整个控制的过程和原理是同样的。

010: 能不能说说 TCP 的拥塞控制？

上一节所说的流量控制发生在发送端跟接收端之间，并无考虑到整个网络环境的影响，若是说当前网络特别差，特别容易丢包，那么发送端就应该注意一些了。而这，也正是拥塞控制须要处理的问题。

对于拥塞控制来讲，TCP 每条链接都须要维护两个核心状态:

• 拥塞窗口（Congestion Window，cwnd）
• 慢启动阈值（Slow Start Threshold，ssthresh）

涉及到的算法有这几个:

• 慢启动
• 拥塞避免
• 快速重传和快速恢复

接下来，咱们就来一一拆解这些状态和算法。首先，从拥塞窗口提及。

拥塞窗口

拥塞窗口（Congestion Window，cwnd）是指目前本身还能传输的数据量大小。

那么以前介绍了接收窗口的概念，二者有什么区别呢？

• 接收窗口(rwnd)是接收端给的限制
• 拥塞窗口(cwnd)是发送端的限制

限制谁呢？

限制的是发送窗口的大小。

有了这两个窗口，如何来计算发送窗口？

发送窗口大小 = min(rwnd, cwnd)

取二者的较小值。而拥塞控制，就是来控制cwnd的变化。

慢启动

刚开始进入传输数据的时候，你是不知道如今的网路究竟是稳定仍是拥堵的，若是作的太激进，发包太急，那么疯狂丢包，形成雪崩式的网络灾难。

所以，拥塞控制首先就是要采用一种保守的算法来慢慢地适应整个网路，这种算法叫慢启动。运做过程以下:

• 首先，三次握手，双方宣告本身的接收窗口大小
• 双方初始化本身的拥塞窗口(cwnd)大小
• 在开始传输的一段时间，发送端每收到一个 ACK，拥塞窗口大小加 1，也就是说，每通过一个 RTT，cwnd 翻倍。若是说初始窗口为 10，那么第一轮 10 个报文传完且发送端收到 ACK 后，cwnd 变为 20，第二轮变为 40，第三轮变为 80，依次类推。

难道就这么无止境地翻倍下去？固然不可能。它的阈值叫作慢启动阈值，当 cwnd 到达这个阈值以后，比如踩了下刹车，别涨了那么快了，老铁，先 hold 住！

在到达阈值后，如何来控制 cwnd 的大小呢？

这就是拥塞避免作的事情了。

拥塞避免

原来每收到一个 ACK，cwnd 加1，如今到达阈值了，cwnd 只能加这么一点: 1 / cwnd。那你仔细算算，一轮 RTT 下来，收到 cwnd 个 ACK, 那最后拥塞窗口的大小 cwnd 总共才增长 1。

也就是说，之前一个 RTT 下来，cwnd翻倍，如今cwnd只是增长 1 而已。

固然，慢启动和拥塞避免是一块儿做用的，是一体的。

快速重传和快速恢复

快速重传

在 TCP 传输的过程当中，若是发生了丢包，即接收端发现数据段不是按序到达的时候，接收端的处理是重复发送以前的 ACK。

好比第 5 个包丢了，即便第 六、7 个包到达的接收端，接收端也一概返回第 4 个包的 ACK。当发送端收到 3 个重复的 ACK 时，意识到丢包了，因而立刻进行重传，不用等到一个 RTO 的时间到了才重传。

这就是快速重传，它解决的是是否须要重传的问题。

选择性重传

那你可能会问了，既然要重传，那么只重传第 5 个包仍是第五、六、7 个包都重传呢？

固然第 六、7 个都已经到达了，TCP 的设计者也不傻，已经传过去干吗还要传？干脆记录一下哪些包到了，哪些没到，针对性地重传。

在收到发送端的报文后，接收端回复一个 ACK 报文，那么在这个报文首部的可选项中，就能够加上SACK这个属性，经过left edge和right edge告知发送端已经收到了哪些区间的数据报。所以，即便第 5 个包丢包了，当收到第 六、7 个包以后，接收端依然会告诉发送端，这两个包到了。剩下第 5 个包没到，就重传这个包。这个过程也叫作选择性重传(SACK，Selective Acknowledgment)，它解决的是如何重传的问题。

快速恢复

固然，发送端收到三次重复 ACK 以后，发现丢包，以为如今的网络已经有些拥塞了，本身会进入快速恢复阶段。

在这个阶段，发送端以下改变：

• 拥塞阈值下降为 cwnd 的一半
• cwnd 的大小变为拥塞阈值
• cwnd 线性增长

以上就是 TCP 拥塞控制的经典算法: 慢启动、拥塞避免、快速重传和快速恢复。

011: 能不能说说 Nagle 算法和延迟确认？

Nagle 算法

试想一个场景，发送端不停地给接收端发很小的包，一次只发 1 个字节，那么发 1 千个字节须要发 1000 次。这种频繁的发送是存在问题的，不光是传输的时延消耗，发送和确认自己也是须要耗时的，频繁的发送接收带来了巨大的时延。

而避免小包的频繁发送，这就是 Nagle 算法要作的事情。

具体来讲，Nagle 算法的规则以下:

• 当第一次发送数据时不用等待，就算是 1byte 的小包也当即发送

• 后面发送知足下面条件之一就能够发了:

  • 数据包大小达到最大段大小(Max Segment Size, 即 MSS)
  • 以前全部包的 ACK 都已接收到

延迟确认

试想这样一个场景，当我收到了发送端的一个包，而后在极短的时间内又接收到了第二个包，那我是一个个地回复，仍是稍微等一下，把两个包的 ACK 合并后一块儿回复呢？

延迟确认(delayed ack)所作的事情，就是后者，稍稍延迟，而后合并 ACK，最后才回复给发送端。TCP 要求这个延迟的时延必须小于500ms，通常操做系统实现都不会超过200ms。

不过须要主要的是，有一些场景是不能延迟确认的，收到了就要立刻回复:

• 接收到了大于一个 frame 的报文，且须要调整窗口大小
• TCP 处于 quickack 模式（经过tcp_in_quickack_mode设置）
• 发现了乱序包

二者一块儿使用会怎样？

前者意味着延迟发，后者意味着延迟接收，会形成更大的延迟，产生性能问题。

012. 如何理解 TCP 的 keep-alive？

你们都据说过 http 的keep-alive, 不过 TCP 层面也是有keep-alive机制，并且跟应用层不太同样。

试想一个场景，当有一方由于网络故障或者宕机致使链接失效，因为 TCP 并非一个轮询的协议，在下一个数据包到达以前，对端对链接失效的状况是一无所知的。

这个时候就出现了 keep-alive, 它的做用就是探测对端的链接有没有失效。

在 Linux 下，能够这样查看相关的配置:

sudo sysctl -a | grep keepalive
​
// 每隔 7200 s 检测一次
net.ipv4.tcp_keepalive_time = 7200
// 一次最多重传 9 个包
net.ipv4.tcp_keepalive_probes = 9
// 每一个包的间隔重传间隔 75 s
net.ipv4.tcp_keepalive_intvl = 75

不过，现状是大部分的应用并无默认开启 TCP 的keep-alive选项，为何？

站在应用的角度:

• 7200s 也就是两个小时检测一次，时间太长
• 时间再短一些，也难以体现其设计的初衷, 即检测长时间的死链接

所以是一个比较尴尬的设计。

关注公众号：网络技术平台，回复 “ 资料 ” 获取视频、培训教程、实验手册、电子书。