【转】TCP那些事（上，下）

TCP是一个巨复杂的协议，由于他要解决不少问题，而这些问题又带出了不少子问题和阴暗面。因此学习TCP自己是个比较痛苦的过程，但对于学习的过程却能让人有不少收获。关于TCP这个协议的细节，我仍是推荐你去看W.Richard Stevens的《TCP/IP 详解 卷1：协议》（固然，你也能够去读一下RFC793以及后面N多的RFC）。另外，本文我会使用英文术语，这样方便你经过这些英文关键词来查找相关的技术文档。

之因此想写这篇文章，目的有三个，

• 一个是想锻炼一下本身是否能够用简单的篇幅把这么复杂的TCP协议描清楚的能力。
• 另外一个是以为如今的好多程序员基本上不会认认真真地读本书，喜欢快餐文化，因此，但愿这篇快餐文章可让你对TCP这个古典技术有所了解，并能体会到软件设计中的种种难处。而且你能够从中有一些软件设计上的收获。
• 最重要的但愿这些基础知识可让你搞清不少之前一些似是而非的东西，而且你能意识到基础的重要。

因此，本文不会面面俱到，只是对TCP协议、算法和原理的科普。

 

我原本只想写一个篇幅的文章的，可是TCP真TMD的复杂，比C++复杂多了，这30多年来，各类优化变种争论和修改。因此，写着写着就发现只有砍成两篇。

• 上篇中，主要向你介绍TCP协议的定义和丢包时的重传机制。
• 下篇中，重点介绍TCP的流迭、拥塞处理。

废话少说，首先，咱们须要知道TCP在网络OSI的七层模型中的第四层——Transport层，IP在第三层——Network层，ARP在第二层——Data Link层，在第二层上的数据，咱们叫Frame，在第三层上的数据叫Packet，第四层的数据叫Segment。

首先，咱们须要知道，咱们程序的数据首先会打到TCP的Segment中，而后TCP的Segment会打到IP的Packet中，而后再打到以太网Ethernet的Frame中，传到对端后，各个层解析本身的协议，而后把数据交给更高层的协议处理。

TCP头格式

接下来，咱们来看一下TCP头的格式

TCP头格式（图片来源）

你须要注意这么几点：

• TCP的包是没有IP地址的，那是IP层上的事。可是有源端口和目标端口。
• 一个TCP链接须要四个元组来表示是同一个链接（src_ip, src_port, dst_ip, dst_port）准确说是五元组，还有一个是协议。但由于这里只是说TCP协议，因此，这里我只说四元组。
• 注意上图中的四个很是重要的东西：
  • Sequence Number是包的序号，用来解决网络包乱序（reordering）问题。
  • Acknowledgement Number就是ACK——用于确认收到，用来解决不丢包的问题。
  • Window又叫Advertised-Window，也就是著名的滑动窗口（Sliding Window），用于解决流控的。
  • TCP Flag ，也就是包的类型，主要是用于操控TCP的状态机的。

关于其它的东西，能够参看下面的图示

（图片来源）

TCP的状态机

其实，网络上的传输是没有链接的，包括TCP也是同样的。而TCP所谓的“链接”，其实只不过是在通信的双方维护一个“链接状态”，让它看上去好像有链接同样。因此，TCP的状态变换是很是重要的。

下面是：“TCP协议的状态机”（图片来源） 和 “TCP建连接”、“TCP断连接”、“传数据” 的对照图，我把两个图并排放在一块儿，这样方便在你对照着看。另外，下面这两个图很是很是的重要，你必定要记牢。（吐个槽：看到这样复杂的状态机，就知道这个协议有多复杂，复杂的东西老是有不少坑爹的事情，因此TCP协议其实也挺坑爹的）

 

不少人会问，为何建连接要3次握手，断连接须要4次挥手？

• 对于建连接的3次握手，主要是要初始化Sequence Number 的初始值。通讯的双方要互相通知对方本身的初始化的Sequence Number（缩写为ISN：Inital Sequence Number）——因此叫SYN，全称Synchronize Sequence Numbers。也就上图中的 x 和 y。这个号要做为之后的数据通讯的序号，以保证应用层接收到的数据不会由于网络上的传输的问题而乱序（TCP会用这个序号来拼接数据）。

• 对于4次挥手，其实你仔细看是2次，由于TCP是全双工的，因此，发送方和接收方都须要Fin和Ack。只不过，有一方是被动的，因此看上去就成了所谓的4次挥手。若是两边同时断链接，那就会就进入到CLOSING状态，而后到达TIME_WAIT状态。下图是双方同时断链接的示意图（你一样能够对照着TCP状态机看）：

两端同时断链接（图片来源）

 

另外，有几个事情须要注意一下：

• 关于建链接时SYN超时。试想一下，若是server端接到了clien发的SYN后回了SYN-ACK后client掉线了，server端没有收到client回来的ACK，那么，这个链接处于一个中间状态，即没成功，也没失败。因而，server端若是在必定时间内没有收到的TCP会重发SYN-ACK。在Linux下，默认重试次数为5次，重试的间隔时间从1s开始每次都翻售，5次的重试时间间隔为1s, 2s, 4s, 8s, 16s，总共31s，第5次发出后还要等32s都知道第5次也超时了，因此，总共须要 1s + 2s + 4s+ 8s+ 16s + 32s = 2^6 -1 = 63s，TCP才会把断开这个链接。

• 关于SYN Flood攻击。一些恶意的人就为此制造了SYN Flood攻击——给服务器发了一个SYN后，就下线了，因而服务器须要默认等63s才会断开链接，这样，攻击者就能够把服务器的syn链接的队列耗尽，让正常的链接请求不能处理。因而，Linux下给了一个叫tcp_syncookies的参数来应对这个事——当SYN队列满了后，TCP会经过源地址端口、目标地址端口和时间戳打造出一个特别的Sequence Number发回去（又叫cookie），若是是攻击者则不会有响应，若是是正常链接，则会把这个 SYN Cookie发回来，而后服务端能够经过cookie建链接（即便你不在SYN队列中）。请注意，请先千万别用tcp_syncookies来处理正常的大负载的链接的状况。由于，synccookies是妥协版的TCP协议，并不严谨。对于正常的请求，你应该调整三个TCP参数可供你选择，第一个是：tcp_synack_retries 能够用他来减小重试次数；第二个是：tcp_max_syn_backlog，能够增大SYN链接数；第三个是：tcp_abort_on_overflow 处理不过来干脆就直接拒绝链接了。

• 关于ISN的初始化。ISN是不能hard code的，否则会出问题的——好比：若是链接建好后始终用1来作ISN，若是client发了30个segment过去，可是网络断了，因而 client重连，又用了1作ISN，可是以前链接的那些包到了，因而就被当成了新链接的包，此时，client的Sequence Number 多是3，而Server端认为client端的这个号是30了。全乱了。RFC793中说，ISN会和一个假的时钟绑在一块儿，这个时钟会在每4微秒对ISN作加一操做，直到超过2^32，又从0开始。这样，一个ISN的周期大约是4.55个小时。由于，咱们假设咱们的TCP Segment在网络上的存活时间不会超过Maximum Segment Lifetime（缩写为MSL – Wikipedia语条），因此，只要MSL的值小于4.55小时，那么，咱们就不会重用到ISN。

• 关于 MSL 和 TIME_WAIT。经过上面的ISN的描述，相信你也知道MSL是怎么来的了。咱们注意到，在TCP的状态图中，从TIME_WAIT状态到CLOSED状态，有一个超时设置，这个超时设置是 2*MSL（RFC793定义了MSL为2分钟，Linux设置成了30s）为何要这有TIME_WAIT？为何不直接给转成CLOSED状态呢？主要有两个缘由：1）TIME_WAIT确保有足够的时间让对端收到了ACK，若是被动关闭的那方没有收到Ack，就会触发被动端重发Fin，一来一去正好2个MSL，2）有足够的时间让这个链接不会跟后面的链接混在一块儿（你要知道，有些自作主张的路由器会缓存IP数据包，若是链接被重用了，那么这些延迟收到的包就有可能会跟新链接混在一块儿）。你能够看看这篇文章《TIME_WAIT and its design implications for protocols and scalable client server systems》

• 关于TIME_WAIT数量太多。从上面的描述咱们能够知道，TIME_WAIT是个很重要的状态，可是若是在大并发的短连接下，TIME_WAIT 就会太多，这也会消耗不少系统资源。只要搜一下，你就会发现，十有八九的处理方式都是教你设置两个参数，一个叫tcp_tw_reuse，另外一个叫tcp_tw_recycle的参数，这两个参数默认值都是被关闭的，后者recyle比前者resue更为激进，resue要温柔一些。另外，若是使用tcp_tw_reuse，必需设置tcp_timestamps=1，不然无效。这里，你必定要注意，打开这两个参数会有比较大的坑——可能会让TCP链接出一些诡异的问题（由于如上述同样，若是不等待超时重用链接的话，新的链接可能会建不上。正如官方文档上说的同样“It should not be changed without advice/request of technical experts”）。

• 关于tcp_tw_reuse。官方文档上说tcp_tw_reuse 加上tcp_timestamps（又叫PAWS, for Protection Against Wrapped Sequence Numbers）能够保证协议的角度上的安全，可是你须要tcp_timestamps在两边都被打开（你能够读一下tcp_twsk_unique的源码 ）。我我的估计仍是有一些场景会有问题。

• 关于tcp_tw_recycle。若是是tcp_tw_recycle被打开了话，会假设对端开启了tcp_timestamps，而后会去比较时间戳，若是时间戳变大了，就能够重用。可是，若是对端是一个NAT网络的话（如：一个公司只用一个IP出公网）或是对端的IP被另外一台重用了，这个事就复杂了。建连接的SYN可能就被直接丢掉了（你可能会看到connection time out的错误）（若是你想观摩一下Linux的内核代码，请参看源码 tcp_timewait_state_process）。

• 关于tcp_max_tw_buckets。这个是控制并发的TIME_WAIT的数量，默认值是180000，若是超限，那么，系统会把多的给destory掉，而后在日志里打一个警告（如：time wait bucket table overflow），官网文档说这个参数是用来对抗DDoS攻击的。也说的默认值180000并不小。这个仍是须要根据实际状况考虑。

Again，使用tcp_tw_reuse和tcp_tw_recycle来解决TIME_WAIT的问题是很是很是危险的，由于这两个参数违反了TCP协议（RFC 1122） 

其实，TIME_WAIT表示的是你主动断链接，因此，这就是所谓的“不做死不会死”。试想，若是让对端断链接，那么这个破问题就是对方的了，呵呵。另外，若是你的服务器是于HTTP服务器，那么设置一个HTTP的KeepAlive有多重要（浏览器会重用一个TCP链接来处理多个HTTP请求），而后让客户端去断连接（你要当心，浏览器可能会很是贪婪，他们不到万不得已不会主动断链接）。

数据传输中的Sequence Number

下图是我从Wireshark中截了个我在访问coolshell.cn时的有数据传输的图给你看一下，SeqNum是怎么变的。（使用Wireshark菜单中的Statistics ->Flow Graph… ）

你能够看到，SeqNum的增长是和传输的字节数相关的。上图中，三次握手后，来了两个Len:1440的包，而第二个包的SeqNum就成了1441。而后第一个ACK回的是1441，表示第一个1440收到了。

注意：若是你用Wireshark抓包程序看3次握手，你会发现SeqNum老是为0，不是这样的，Wireshark为了显示更友好，使用了Relative SeqNum——相对序号，你只要在右键菜单中的protocol preference 中取消掉就能够看到“Absolute SeqNum”了

TCP重传机制

TCP要保证全部的数据包均可以到达，因此，必须要有重传机制。

注意，接收端给发送端的Ack确认只会确认最后一个连续的包，好比，发送端发了1,2,3,4,5一共五份数据，接收端收到了1，2，因而回ack 3，而后收到了4（注意此时3没收到），此时的TCP会怎么办？咱们要知道，由于正如前面所说的，SeqNum和Ack是以字节数为单位，因此ack的时候，不能跳着确认，只能确认最大的连续收到的包，否则，发送端就觉得以前的都收到了。

超时重传机制

一种是不回ack，死等3，当发送方发现收不到3的ack超时后，会重传3。一旦接收方收到3后，会ack 回 4——意味着3和4都收到了。

可是，这种方式会有比较严重的问题，那就是由于要死等3，因此会致使4和5即使已经收到了，而发送方也彻底不知道发生了什么事，由于没有收到Ack，因此，发送方可能会悲观地认为也丢了，因此有可能也会致使4和5的重传。

对此有两种选择：

• 一种是仅重传timeout的包。也就是第3份数据。
• 另外一种是重传timeout后全部的数据，也就是第3，4，5这三份数据。

这两种方式有好也有很差。第一种会节省带宽，可是慢，第二种会快一点，可是会浪费带宽，也可能会有无用功。但整体来讲都很差。由于都在等timeout，timeout可能会很长（在下篇会说TCP是怎么动态地计算出timeout的）

快速重传机制

因而，TCP引入了一种叫Fast Retransmit 的算法，不以时间驱动，而以数据驱动重传。也就是说，若是，包没有连续到达，就ack最后那个可能被丢了的包，若是发送方连续收到3次相同的ack，就重传。Fast Retransmit的好处是不用等timeout了再重传。

好比：若是发送方发出了1，2，3，4，5份数据，第一份先到送了，因而就ack回2，结果2由于某些缘由没收到，3到达了，因而仍是ack回2，后面的4和5都到了，可是仍是ack回2，由于2仍是没有收到，因而发送端收到了三个ack=2的确认，知道了2尚未到，因而就立刻重转2。而后，接收端收到了2，此时由于3，4，5都收到了，因而ack回6。示意图以下：

Fast Retransmit只解决了一个问题，就是timeout的问题，它依然面临一个艰难的选择，就是，是重传以前的一个仍是重传全部的问题。对于上面的示例来讲，是重传#2呢仍是重传#2，#3，#4，#5呢？由于发送端并不清楚这连续的3个ack(2)是谁传回来的？也许发送端发了20份数据，是#6，#10，#20传来的呢。这样，发送端颇有可能要重传从2到20的这堆数据（这就是某些TCP的实际的实现）。可见，这是一把双刃剑。

SACK 方法

另一种更好的方式叫：Selective Acknowledgment (SACK)（参看RFC 2018），这种方式须要在TCP头里加一个SACK的东西，ACK仍是Fast Retransmit的ACK，SACK则是汇报收到的数据碎版。参看下图：

这样，在发送端就能够根据回传的SACK来知道哪些数据到了，哪些没有到。因而就优化了Fast Retransmit的算法。固然，这个协议须要两边都支持。在 Linux下，能够经过tcp_sack参数打开这个功能（Linux 2.4后默认打开）。

这里还须要注意一个问题——接收方Reneging，所谓Reneging的意思就是接收方有权把已经报给发送端SACK里的数据给丢了。这样干是不被鼓励的，由于这个事会把问题复杂化了，可是，接收方这么作可能会有些极端状况，好比要把内存给别的更重要的东西。因此，发送方也不能彻底依赖SACK，仍是要依赖ACK，并维护Time-Out，若是后续的ACK没有增加，那么仍是要把SACK的东西重传，另外，接收端这边永远不能把SACK的包标记为Ack。

注意：SACK会消费发送方的资源，试想，若是一个攻击者给数据发送方发一堆SACK的选项，这会致使发送方开始要重传甚至遍历已经发出的数据，这会消耗不少发送端的资源。详细的东西请参看《TCP SACK的性能权衡》

Duplicate SACK – 重复收到数据的问题

Duplicate SACK又称D-SACK，其主要使用了SACK来告诉发送方有哪些数据被重复接收了。RFC-2883 里有详细描述和示例。下面举几个例子（来源于RFC-2883）

D-SACK使用了SACK的第一个段来作标志，

• 若是SACK的第一个段的范围被ACK所覆盖，那么就是D-SACK

• 若是SACK的第一个段的范围被SACK的第二个段覆盖，那么就是D-SACK

示例一：ACK丢包

下面的示例中，丢了两个ACK，因此，发送端重传了第一个数据包（3000-3499），因而接收端发现重复收到，因而回了一个SACK=3000-3500，由于ACK都到了4000意味着收到了4000以前的全部数据，因此这个SACK就是D-SACK——旨在告诉发送端我收到了重复的数据，并且咱们的发送端还知道，数据包没有丢，丢的是ACK包。

1 2 3 4 5 6 7

Transmitted  Received    ACK Sent Segment      Segment     (Including SACK Blocks)   3000-3499    3000-3499   3500 (ACK dropped) 3500-3999    3500-3999   4000 (ACK dropped) 3000-3499    3000-3499   4000, SACK=3000-3500                                      ---------

 示例二，网络延误

下面的示例中，网络包（1000-1499）被网络给延误了，致使发送方没有收到ACK，然后面到达的三个包触发了“Fast Retransmit算法”，因此重传，但重传时，被延误的包又到了，因此，回了一个SACK=1000-1500，由于ACK已到了3000，因此，这个SACK是D-SACK——标识收到了重复的包。

这个案例下，发送端知道以前由于“Fast Retransmit算法”触发的重传不是由于发出去的包丢了，也不是由于回应的ACK包丢了，而是由于网络延时了。

1 2 3 4 5 6 7 8 9 10 11

Transmitted    Received    ACK Sent Segment        Segment     (Including SACK Blocks)   500-999        500-999     1000 1000-1499      (delayed) 1500-1999      1500-1999   1000, SACK=1500-2000 2000-2499      2000-2499   1000, SACK=1500-2500 2500-2999      2500-2999   1000, SACK=1500-3000 1000-1499      1000-1499   3000                 1000-1499   3000, SACK=1000-1500                                        ---------

 

可见，引入了D-SACK，有这么几个好处：

1）可让发送方知道，是发出去的包丢了，仍是回来的ACK包丢了。

2）是否是本身的timeout过小了，致使重传。

3）网络上出现了先发的包后到的状况（又称reordering）

4）网络上是否是把个人数据包给复制了。

 知道这些东西能够很好得帮助TCP了解网络状况，从而能够更好的作网络上的流控。

Linux下的tcp_dsack参数用于开启这个功能（Linux 2.4后默认打开）

好了，上篇就到这里结束了。若是你以为我写得还比较浅显易懂，那么，欢迎移步看下篇《TCP的那些事（下）》

 

---

---

 

这篇文章是下篇，因此若是你对TCP不熟悉的话，还请你先看看上篇《TCP的那些事儿（上）》 上篇中，咱们介绍了TCP的协议头、状态机、数据重传中的东西。可是TCP要解决一个很大的事，那就是要在一个网络根据不一样的状况来动态调整本身的发包的速度，小则让本身的链接更稳定，大则让整个网络更稳定。在你阅读下篇以前，你须要作好准备，本篇文章有好些算法和策略，可能会引起你的各类思考，让你的大脑分配不少内存和计算资源，因此，不适合在厕所中阅读。

TCP的RTT算法

从前面的TCP重传机制咱们知道Timeout的设置对于重传很是重要。

• 设长了，重发就慢，丢了老半天才重发，没有效率，性能差；
• 设短了，会致使可能并无丢就重发。因而重发的就快，会增长网络拥塞，致使更多的超时，更多的超时致使更多的重发。

并且，这个超时时间在不一样的网络的状况下，根本没有办法设置一个死的值。只能动态地设置。 为了动态地设置，TCP引入了RTT——Round Trip Time，也就是一个数据包从发出去到回来的时间。这样发送端就大约知道须要多少的时间，从而能够方便地设置Timeout——RTO（Retransmission TimeOut），以让咱们的重传机制更高效。 听起来彷佛很简单，好像就是在发送端发包时记下t0，而后接收端再把这个ack回来时再记一个t1，因而RTT = t1 – t0。没那么简单，这只是一个采样，不能表明广泛状况。

 

经典算法

RFC793 中定义的经典算法是这样的：

1）首先，先采样RTT，记下最近好几回的RTT值。

2）而后作平滑计算SRTT（ Smoothed RTT）。公式为：（其中的 α 取值在0.8 到 0.9之间，这个算法英文叫Exponential weighted moving average，中文叫：加权移动平均）

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

3）开始计算RTO。公式以下：

RTO = min [ UBOUND,  max [ LBOUND,   (β * SRTT) ]  ]

其中：

• UBOUND是最大的timeout时间，上限值
• LBOUND是最小的timeout时间，下限值
• β 值通常在1.3到2.0之间。

Karn / Partridge 算法

可是上面的这个算法在重传的时候会出有一个终极问题——你是用第一次发数据的时间和ack回来的时间作RTT样本值，仍是用重传的时间和ACK回来的时间作RTT样本值？

这个问题不管你选那头都是按下葫芦起了瓢。 以下图所示：

• 状况（a）是ack没回来，因此重传。若是你计算第一次发送和ACK的时间，那么，明显算大了。
• 状况（b）是ack回来慢了，可是致使了重传，但刚重传不一下子，以前ACK就回来了。若是你是算重传的时间和ACK回来的时间的差，就会算短了。

因此1987年的时候，搞了一个叫Karn / Partridge Algorithm，这个算法的最大特色是——忽略重传，不把重传的RTT作采样（你看，你不须要去解决不存在的问题）。

可是，这样一来，又会引起一个大BUG——若是在某一时间，网络闪动，忽然变慢了，产生了比较大的延时，这个延时致使要重转全部的包（由于以前的RTO很小），因而，由于重转的不算，因此，RTO就不会被更新，这是一个灾难。 因而Karn算法用了一个取巧的方式——只要一发生重传，就对现有的RTO值翻倍（这就是所谓的 Exponential backoff），很明显，这种死规矩对于一个须要估计比较准确的RTT也不靠谱。

Jacobson / Karels 算法

前面两种算法用的都是“加权移动平均”，这种方法最大的毛病就是若是RTT有一个大的波动的话，很难被发现，由于被平滑掉了。因此，1988年，又有人推出来了一个新的算法，这个算法叫Jacobson / Karels Algorithm（参看RFC6289）。这个算法引入了最新的RTT的采样和平滑过的SRTT的差距作因子来计算。 公式以下：（其中的DevRTT是Deviation RTT的意思）

SRTT = SRTT + α (RTT – SRTT)  —— 计算平滑RTT

DevRTT = (1-β)*DevRTT + β*(|RTT-SRTT|) ——计算平滑RTT和真实的差距（加权移动平均）

RTO= µ * SRTT + ∂ *DevRTT —— 神同样的公式

（其中：在Linux下，α = 0.125，β = 0.25， μ = 1，∂ = 4 ——这就是算法中的“调得一手好参数”，nobody knows why, it just works…） 最后的这个算法在被用在今天的TCP协议中（Linux的源代码在：tcp_rtt_estimator）。

TCP滑动窗口

须要说明一下，若是你不了解TCP的滑动窗口这个事，你等于不了解TCP协议。咱们都知道，TCP必须要解决的可靠传输以及包乱序（reordering）的问题，因此，TCP必须要知道网络实际的数据处理带宽或是数据处理速度，这样才不会引发网络拥塞，致使丢包。

因此，TCP引入了一些技术和设计来作网络流控，Sliding Window是其中一个技术。 前面咱们说过，TCP头里有一个字段叫Window，又叫Advertised-Window，这个字段是接收端告诉发送端本身还有多少缓冲区能够接收数据。因而发送端就能够根据这个接收端的处理能力来发送数据，而不会致使接收端处理不过来。 为了说明滑动窗口，咱们须要先看一下TCP缓冲区的一些数据结构：

上图中，咱们能够看到：

• 接收端LastByteRead指向了TCP缓冲区中读到的位置，NextByteExpected指向的地方是收到的连续包的最后一个位置，LastByteRcved指向的是收到的包的最后一个位置，咱们能够看到中间有些数据尚未到达，因此有数据空白区。

• 发送端的LastByteAcked指向了被接收端Ack过的位置（表示成功发送确认），LastByteSent表示发出去了，但尚未收到成功确认的Ack，LastByteWritten指向的是上层应用正在写的地方。

因而：

• 接收端在给发送端回ACK中会汇报本身的AdvertisedWindow = MaxRcvBuffer – LastByteRcvd – 1;

• 而发送方会根据这个窗口来控制发送数据的大小，以保证接收方能够处理。

下面咱们来看一下发送方的滑动窗口示意图：

（图片来源）

上图中分红了四个部分，分别是：（其中那个黑模型就是滑动窗口）

• #1已收到ack确认的数据。
• #2发还没收到ack的。
• #3在窗口中尚未发出的（接收方还有空间）。
• #4窗口之外的数据（接收方没空间）

下面是个滑动后的示意图（收到36的ack，并发出了46-51的字节）：

下面咱们来看一个接受端控制发送端的图示：

（图片来源）

Zero Window

上图，咱们能够看到一个处理缓慢的Server（接收端）是怎么把Client（发送端）的TCP Sliding Window给降成0的。此时，你必定会问，若是Window变成0了，TCP会怎么样？是否是发送端就不发数据了？是的，发送端就不发数据了，你能够想像成“Window Closed”，那你必定还会问，若是发送端不发数据了，接收方一下子Window size 可用了，怎么通知发送端呢？

解决这个问题，TCP使用了Zero Window Probe技术，缩写为ZWP，也就是说，发送端在窗口变成0后，会发ZWP的包给接收方，让接收方来ack他的Window尺寸，通常这个值会设置成3次，第次大约30-60秒（不一样的实现可能会不同）。若是3次事后仍是0的话，有的TCP实现就会发RST把连接断了。

注意：只要有等待的地方均可能出现DDoS攻击，Zero Window也不例外，一些攻击者会在和HTTP建好链发完GET请求后，就把Window设置为0，而后服务端就只能等待进行ZWP，因而攻击者会并发大量的这样的请求，把服务器端的资源耗尽。（关于这方面的攻击，你们能够移步看一下Wikipedia的SockStress词条）

另外，Wireshark中，你可使用tcp.analysis.zero_window来过滤包，而后使用右键菜单里的follow TCP stream，你能够看到ZeroWindowProbe及ZeroWindowProbeAck的包。

Silly Window Syndrome

Silly Window Syndrome翻译成中文就是“糊涂窗口综合症”。正如你上面看到的同样，若是咱们的接收方太忙了，来不及取走Receive Windows里的数据，那么，就会致使发送方愈来愈小。到最后，若是接收方腾出几个字节并告诉发送方如今有几个字节的window，而咱们的发送方会义无反顾地发送这几个字节。

要知道，咱们的TCP+IP头有40个字节，为了几个字节，要达上这么大的开销，这太不经济了。

另外，你须要知道网络上有个MTU，对于以太网来讲，MTU是1500字节，除去TCP+IP头的40个字节，真正的数据传输能够有1460，这就是所谓的MSS（Max Segment Size）注意，TCP的RFC定义这个MSS的默认值是536，这是由于 RFC 791里说了任何一个IP设备都得最少接收576尺寸的大小（实际上来讲576是拨号的网络的MTU，而576减去IP头的20个字节就是536）。

若是你的网络包能够塞满MTU，那么你能够用满整个带宽，若是不能，那么你就会浪费带宽。（大于MTU的包有两种结局，一种是直接被丢了，另外一种是会被从新分块打包发送） 你能够想像成一个MTU就至关于一个飞机的最多能够装的人，若是这飞机里满载的话，带宽最高，若是一个飞机只运一我的的话，无疑成本增长了，也而至关二。

因此，Silly Windows Syndrome这个现像就像是你原本能够坐200人的飞机里只作了一两我的。 要解决这个问题也不难，就是避免对小的window size作出响应，直到有足够大的window size再响应，这个思路能够同时实如今sender和receiver两端。

• 若是这个问题是由Receiver端引发的，那么就会使用 David D Clark’s 方案。在receiver端，若是收到的数据致使window size小于某个值，能够直接ack(0)回sender，这样就把window给关闭了，也阻止了sender再发数据过来，等到receiver端处理了一些数据后windows size 大于等于了MSS，或者，receiver buffer有一半为空，就能够把window打开让send 发送数据过来。

• 若是这个问题是由Sender端引发的，那么就会使用著名的 Nagle’s algorithm。这个算法的思路也是延时处理，他有两个主要的条件：1）要等到 Window Size>=MSS 或是 Data Size >=MSS，2）收到以前发送数据的ack回包，他才会发数据，不然就是在攒数据。

另外，Nagle算法默认是打开的，因此，对于一些须要小包场景的程序——好比像telnet或ssh这样的交互性比较强的程序，你须要关闭这个算法。你能够在Socket设置TCP_NODELAY选项来关闭这个算法（关闭Nagle算法没有全局参数，须要根据每一个应用本身的特色来关闭）

1	setsockopt(sock_fd, IPPROTO_TCP, TCP_NODELAY, ( char *)&value, sizeof ( int ));

另外，网上有些文章说TCP_CORK的socket option是也关闭Nagle算法，这不对。TCP_CORK实际上是更新激进的Nagle算汉，彻底禁止小包发送，而Nagle算法没有禁止小包发送，只是禁止了大量的小包发送。最好不要两个选项都设置。

TCP的拥塞处理 – Congestion Handling

上面咱们知道了，TCP经过Sliding Window来作流控（Flow Control），可是TCP以为这还不够，由于Sliding Window须要依赖于链接的发送端和接收端，其并不知道网络中间发生了什么。TCP的设计者以为，一个伟大而牛逼的协议仅仅作到流控并不够，由于流控只是网络模型4层以上的事，TCP的还应该更聪明地知道整个网络上的事。

具体一点，咱们知道TCP经过一个timer采样了RTT并计算RTO，可是，若是网络上的延时忽然增长，那么，TCP对这个事作出的应对只有重传数据，可是，重传会致使网络的负担更重，因而会致使更大的延迟以及更多的丢包，因而，这个状况就会进入恶性循环被不断地放大。试想一下，若是一个网络内有成千上万的TCP链接都这么行事，那么立刻就会造成“网络风暴”，TCP这个协议就会拖垮整个网络。这是一个灾难。

因此，TCP不能忽略网络上发生的事情，而无脑地一个劲地重发数据，对网络形成更大的伤害。对此TCP的设计理念是：TCP不是一个自私的协议，当拥塞发生的时候，要作自我牺牲。就像交通阻塞同样，每一个车都应该把路让出来，而不要再去抢路了。

关于拥塞控制的论文请参看《Congestion Avoidance and Control》(PDF)

拥塞控制主要是四个算法：1）慢启动，2）拥塞避免，3）拥塞发生，4）快速恢复。这四个算法不是一天都搞出来的，这个四算法的发展经历了不少时间，到今天都还在优化中。 备注:

• 1988年，TCP-Tahoe 提出了1）慢启动，2）拥塞避免，3）拥塞发生时的快速重传
• 1990年，TCP Reno 在Tahoe的基础上增长了4）快速恢复

慢热启动算法 – Slow Start

首先，咱们来看一下TCP的慢热启动。慢启动的意思是，刚刚加入网络的链接，一点一点地提速，不要一上来就像那些特权车同样霸道地把路占满。新同窗上高速仍是要慢一点，不要把已经在高速上的秩序给搞乱了。

慢启动的算法以下(cwnd全称Congestion Window)：

1）链接建好的开始先初始化cwnd = 1，代表能够传一个MSS大小的数据。

2）每当收到一个ACK，cwnd++; 呈线性上升

3）每当过了一个RTT，cwnd = cwnd*2; 呈指数让升

4）还有一个ssthresh（slow start threshold），是一个上限，当cwnd >= ssthresh时，就会进入“拥塞避免算法”（后面会说这个算法）

因此，咱们能够看到，若是网速很快的话，ACK也会返回得快，RTT也会短，那么，这个慢启动就一点也不慢。下图说明了这个过程。

这里，我须要提一下的是一篇Google的论文《An Argument for Increasing TCP’s Initial Congestion Window》Linux 3.0后采用了这篇论文的建议——把cwnd 初始化成了 10个MSS。 而Linux 3.0之前，好比2.6，Linux采用了RFC3390，cwnd是跟MSS的值来变的，若是MSS< 1095，则cwnd = 4；若是MSS>2190，则cwnd=2；其它状况下，则是3。

 拥塞避免算法 – Congestion Avoidance

前面说过，还有一个ssthresh（slow start threshold），是一个上限，当cwnd >= ssthresh时，就会进入“拥塞避免算法”。通常来讲ssthresh的值是65535，单位是字节，当cwnd达到这个值时后，算法以下：

1）收到一个ACK时，cwnd = cwnd + 1/cwnd

2）当每过一个RTT时，cwnd = cwnd + 1

这样就能够避免增加过快致使网络拥塞，慢慢的增长调整到网络的最佳值。很明显，是一个线性上升的算法。

拥塞状态时的算法

前面咱们说过，当丢包的时候，会有两种状况：

1）等到RTO超时，重传数据包。TCP认为这种状况太糟糕，反应也很强烈。

• sshthresh =  cwnd /2
• cwnd 重置为 1
• 进入慢启动过程

2）Fast Retransmit算法，也就是在收到3个duplicate ACK时就开启重传，而不用等到RTO超时。

• TCP Tahoe的实现和RTO超时同样。

• TCP Reno的实现是：
  • cwnd = cwnd /2
  • sshthresh = cwnd
  • 进入快速恢复算法——Fast Recovery

上面咱们能够看到RTO超时后，sshthresh会变成cwnd的一半，这意味着，若是cwnd<=sshthresh时出现的丢包，那么TCP的sshthresh就会减了一半，而后等cwnd又很快地以指数级增涨爬到这个地方时，就会成慢慢的线性增涨。咱们能够看到，TCP是怎么经过这种强烈地震荡快速而当心得找到网站流量的平衡点的。

快速恢复算法 – Fast Recovery

TCP Reno

这个算法定义在RFC5681。快速重传和快速恢复算法通常同时使用。快速恢复算法是认为，你还有3个Duplicated Acks说明网络也不那么糟糕，因此没有必要像RTO超时那么强烈。 注意，正如前面所说，进入Fast Recovery以前，cwnd 和 sshthresh已被更新：

• cwnd = cwnd /2
• sshthresh = cwnd

而后，真正的Fast Recovery算法以下：

• cwnd = sshthresh  + 3 * MSS （3的意思是确认有3个数据包被收到了）
• 重传Duplicated ACKs指定的数据包
• 若是再收到 duplicated Acks，那么cwnd = cwnd +1
• 若是收到了新的Ack，那么，cwnd = sshthresh ，而后就进入了拥塞避免的算法了。

若是你仔细思考一下上面的这个算法，你就会知道，上面这个算法也有问题，那就是——它依赖于3个重复的Acks。注意，3个重复的Acks并不表明只丢了一个数据包，颇有多是丢了好多包。但这个算法只会重传一个，而剩下的那些包只能等到RTO超时，因而，进入了恶梦模式——超时一个窗口就减半一下，多个超时会超成TCP的传输速度呈级数降低，并且也不会触发Fast Recovery算法了。

一般来讲，正如咱们前面所说的，SACK或D-SACK的方法可让Fast Recovery或Sender在作决定时更聪明一些，可是并非全部的TCP的实现都支持SACK（SACK须要两端都支持），因此，须要一个没有SACK的解决方案。而经过SACK进行拥塞控制的算法是FACK（后面会讲）

TCP New Reno

因而，1995年，TCP New Reno（参见 RFC 6582 ）算法提出来，主要就是在没有SACK的支持下改进Fast Recovery算法的——

• 当sender这边收到了3个Duplicated Acks，进入Fast Retransimit模式，开发重传重复Acks指示的那个包。若是只有这一个包丢了，那么，重传这个包后回来的Ack会把整个已经被sender传输出去的数据ack回来。若是没有的话，说明有多个包丢了。咱们叫这个ACK为Partial ACK。

• 一旦Sender这边发现了Partial ACK出现，那么，sender就能够推理出来有多个包被丢了，因而乎继续重传sliding window里未被ack的第一个包。直到再也收不到了Partial Ack，才真正结束Fast Recovery这个过程

咱们能够看到，这个“Fast Recovery的变动”是一个很是激进的玩法，他同时延长了Fast Retransmit和Fast Recovery的过程。

算法示意图

下面咱们来看一个简单的图示以同时看一下上面的各类算法的样子：

 

FACK算法

FACK全称Forward Acknowledgment 算法，论文地址在这里（PDF）Forward Acknowledgement: Refining TCP Congestion Control 这个算法是其于SACK的，前面咱们说过SACK是使用了TCP扩展字段Ack了有哪些数据收到，哪些数据没有收到，他比Fast Retransmit的3 个duplicated acks好处在于，前者只知道有包丢了，不知道是一个仍是多个，而SACK能够准确的知道有哪些包丢了。 因此，SACK可让发送端这边在重传过程当中，把那些丢掉的包重传，而不是一个一个的传，但这样的一来，若是重传的包数据比较多的话，又会致使原本就很忙的网络就更忙了。因此，FACK用来作重传过程当中的拥塞流控。

• 这个算法会把SACK中最大的Sequence Number 保存在snd.fack这个变量中，snd.fack的更新由ack带秋，若是网络一切安好则和snd.una同样（snd.una就是尚未收到ack的地方，也就是前面sliding window里的category #2的第一个地方）

• 而后定义一个awnd = snd.nxt – snd.fack（snd.nxt指向发送端sliding window中正在要被发送的地方——前面sliding windows图示的category#3第一个位置），这样awnd的意思就是在网络上的数据。（所谓awnd意为：actual quantity of data outstanding in the network）

• 若是须要重传数据，那么，awnd = snd.nxt – snd.fack + retran_data，也就是说，awnd是传出去的数据 + 重传的数据。

• 而后触发Fast Recovery 的条件是： ( ( snd.fack – snd.una ) > (3*MSS) ) || (dupacks == 3) ) 。这样一来，就不须要等到3个duplicated acks才重传，而是只要sack中的最大的一个数据和ack的数据比较长了（3个MSS），那就触发重传。在整个重传过程当中cwnd不变。直到当第一次丢包的snd.nxt<=snd.una（也就是重传的数据都被确认了），而后进来拥塞避免机制——cwnd线性上涨。

咱们能够看到若是没有FACK在，那么在丢包比较多的状况下，原来保守的算法会低估了须要使用的window的大小，而须要几个RTT的时间才会完成恢复，而FACK会比较激进地来干这事。 可是，FACK若是在一个网络包会被 reordering的网络里会有很大的问题。

其它拥塞控制算法简介

TCP Vegas 拥塞控制算法

这个算法1994年被提出，它主要对TCP Reno 作了些修改。这个算法经过对RTT的很是重的监控来计算一个基准RTT。而后经过这个基准RTT来估计当前的网络实际带宽，若是实际带宽比咱们的指望的带宽要小或是要多的活，那么就开始线性地减小或增长cwnd的大小。若是这个计算出来的RTT大于了Timeout后，那么，不等ack超时就直接重传。（Vegas 的核心思想是用RTT的值来影响拥塞窗口，而不是经过丢包） 这个算法的论文是《TCP Vegas: End to End Congestion Avoidance on a Global Internet》这篇论文给了Vegas和 New Reno的对比：

关于这个算法实现，你能够参看Linux源码：/net/ipv4/tcp_vegas.h， /net/ipv4/tcp_vegas.c

 

HSTCP(High Speed TCP) 算法

这个算法来自RFC 3649（Wikipedia词条）。其对最基础的算法进行了更改，他使得Congestion Window涨得快，减得慢。其中：

• 拥塞避免时的窗口增加方式： cwnd = cwnd + α(cwnd) / cwnd
• 丢包后窗口降低方式：cwnd = (1- β(cwnd))*cwnd

注：α(cwnd)和β(cwnd)都是函数，若是你要让他们和标准的TCP同样，那么让α(cwnd)=1，β(cwnd)=0.5就能够了。 对于α(cwnd)和β(cwnd)的值是个动态的变换的东西。 关于这个算法的实现，你能够参看Linux源码：/net/ipv4/tcp_highspeed.c

 TCP BIC 算法

2004年，产内出BIC算法。如今你还能够查获得相关的新闻《Google：美科学家研发BIC-TCP协议 速度是DSL六千倍》 BIC全称Binary Increase Congestion control，在Linux 2.6.8中是默认拥塞控制算法。BIC的发明者发这么多的拥塞控制算法都在努力找一个合适的cwnd – Congestion Window，并且BIC-TCP的提出者们看穿了事情的本质，其实这就是一个搜索的过程，因此BIC这个算法主要用的是Binary Search——二分查找来干这个事。 关于这个算法实现，你能够参看Linux源码：/net/ipv4/tcp_bic.c

TCP WestWood算法

westwood采用和Reno相同的慢启动算法、拥塞避免算法。westwood的主要改进方面：在发送端作带宽估计，当探测到丢包时，根据带宽值来设置拥塞窗口、慢启动阈值。 那么，这个算法是怎么测量带宽的？每一个RTT时间，会测量一次带宽，测量带宽的公式很简单，就是这段RTT内成功被ack了多少字节。由于，这个带宽和用RTT计算RTO同样，也是须要从每一个样原本平滑到一个值的——也是用一个加权移平均的公式。 另外，咱们知道，若是一个网络的带宽是每秒能够发送X个字节，而RTT是一个数据发出去后确认须要的时候，因此，X * RTT应该是咱们缓冲区大小。因此，在这个算法中，ssthresh的值就是est_BD * min-RTT(最小的RTT值)，若是丢包是Duplicated ACKs引发的，那么若是cwnd > ssthresh，则 cwin = ssthresh。若是是RTO引发的，cwnd = 1，进入慢启动。   关于这个算法实现，你能够参看Linux源码： /net/ipv4/tcp_westwood.c

其它

更多的算法，你能够从Wikipedia的 TCP Congestion Avoidance Algorithm 词条中找到相关的线索

 后记

好了，到这里我想能够结束了，TCP发展到今天，里面的东西能够写上好几本书。本文主要目的，仍是把你带入这些古典的基础技术和知识中，但愿本文能让你了解TCP，更但愿本文能让你开始有学习这些基础或底层知识的兴趣和信心。

固然，TCP东西太多了，不一样的人可能有不一样的理解，并且本文可能也会有一些荒谬之言甚至错误，还但愿获得您的反馈和批评。

（全文完）

 

 

原文地址：

TCP那些事儿（上）

TCP那些事儿（下）