计算机网络第三章：数据链路层

文章目录

计算机网络第三章：数据链路层
- [🗺️ 开启第三章：爬上 2 楼数据链路层（互动闯关目录）](#🗺️ 开启第三章：爬上 2 楼数据链路层（互动闯关目录）)
- [第一节（第 1 关）：给信封插上"头尾小红旗"（封装成帧与透明传输）](#第一节（第 1 关）：给信封插上“头尾小红旗”（封装成帧与透明传输）)
- - [1.1 第一幕：永不停歇的豆子传送带（为什么要"封装成帧"？）](#1.1 第一幕：永不停歇的豆子传送带（为什么要“封装成帧”？）)
  - [1.2 第二幕：突发乌龙事件！信里居然画着一面"假尾旗"！](#1.2 第二幕：突发乌龙事件！信里居然画着一面“假尾旗”！)
  - [1.3 魔法一：贴"免死金牌" ------ 字符填充法（字节填充）](#1.3 魔法一：贴“免死金牌” —— 字符填充法（字节填充）)
  - [1.4 魔法二：逢五塞零大法 ------ 零比特填充法（全网最聪明的小把戏）](#1.4 魔法二：逢五塞零大法 —— 零比特填充法（全网最聪明的小把戏）)
  - [1.5 📌 本关重点标记（帮你分配脑力）](#1.5 📌 本关重点标记（帮你分配脑力）)
  - [1.6 🤔 第 1 关随堂小挑战与作业批改纠偏](#1.6 🤔 第 1 关随堂小挑战与作业批改纠偏)
  - - [🔍 作业批改与纠偏（极易踩坑点！）](#🔍 作业批改与纠偏（极易踩坑点！）)
- [第二节（第 2 关）：给信封贴上"防伪封条"（奇偶校验与 CRC）](#第二节（第 2 关）：给信封贴上“防伪封条”（奇偶校验与 CRC）)
- - [2.1 第一幕：一道闪电引发的惨案](#2.1 第一幕：一道闪电引发的惨案)
  - [2.2 防伪封条一：初学者的笨办法 ------ 奇偶校验码（Parity Check）](#2.2 防伪封条一：初学者的笨办法 —— 奇偶校验码（Parity Check）)
  - [2.3 防伪封条二：真正的工业界霸主 ------ CRC 循环冗余校验（【★核心必透】）](#2.3 防伪封条二：真正的工业界霸主 —— CRC 循环冗余校验（【★核心必透】）)
  - - [🎲 游戏准备：](#🎲 游戏准备：)
    - [第一步：看除数有几位，就在数据屁股后面补几个 `0`（少补一个）](#第一步：看除数有几位，就在数据屁股后面补几个 0（少补一个）)
    - [第二步：玩"相同为 0，不同为 1"的消消乐除法（模 2 除法）](#第二步：玩“相同为 0，不同为 1”的消消乐除法（模 2 除法）)
    - [第三步：把算出来的余数，填进第一步补的 `0` 里面！](#第三步：把算出来的余数，填进第一步补的 0 里面！)
  - [2.4 📌 本关重点标记（帮你分配脑力）](#2.4 📌 本关重点标记（帮你分配脑力）)
  - [2.5 🤔 第 2 关随堂小挑战与作业复盘](#2.5 🤔 第 2 关随堂小挑战与作业复盘)
  - - [🔍 作业复盘与解析](#🔍 作业复盘与解析)
- [第三节（第 3 关）：扔砖头过河的艺术（流量控制与可靠传输：停止-等待、GBN、SR）](#第三节（第 3 关）：扔砖头过河的艺术（流量控制与可靠传输：停止-等待、GBN、SR）)
- - [3.1 第一幕：最老实的笨办法 ------ 停止-等待协议（Stop-and-Wait）](#3.1 第一幕：最老实的笨办法 —— 停止-等待协议（Stop-and-Wait）)
  - - [意外 1：砖头半路掉进河里了（数据丢失 / 出错被扔掉）](#意外 1：砖头半路掉进河里了（数据丢失 / 出错被扔掉）)
    - [意外 2（极其阴险！）：砖头安全到了，但朋友喊的"收到"被大风吹跑了！（ACK 丢失）](#意外 2（极其阴险！）：砖头安全到了，但朋友喊的“收到”被大风吹跑了！（ACK 丢失）)
  - [3.2 第二幕：停止-等待太慢了！开启"滑动窗口"流水线！](#3.2 第二幕：停止-等待太慢了！开启“滑动窗口”流水线！)
  - [3.3 第三幕：半路掉了一块砖！两兄弟反目成仇（GBN vs SR）](#3.3 第三幕：半路掉了一块砖！两兄弟反目成仇（GBN vs SR）)
  - - [门派 A：强迫症哥哥 ------ 后退 N 帧协议（GBN，Go-Back-N）](#门派 A：强迫症哥哥 —— 后退 N 帧协议（GBN，Go-Back-N）)
    - [门派 B：收纳狂弟弟 ------ 选择重传协议（SR，Selective Repeat）](#门派 B：收纳狂弟弟 —— 选择重传协议（SR，Selective Repeat）)
  - [3.4 📌 本关重点标记（帮你分配脑力）](#3.4 📌 本关重点标记（帮你分配脑力）)
  - [3.5 🤔 第 3 关随堂小挑战与作业复盘](#3.5 🤔 第 3 关随堂小挑战与作业复盘)
  - - [🔍 作业复盘与细节修正](#🔍 作业复盘与细节修正)
- [第四节（第 4 关）：大黑屋里的"抢话潜规则"（CSMA/CD 与最小帧长之谜）](#第四节（第 4 关）：大黑屋里的“抢话潜规则”（CSMA/CD 与最小帧长之谜）)
- - [4.1 第一幕：为什么"先听后发"还是会撞车？](#4.1 第一幕：为什么“先听后发”还是会撞车？)
  - [4.2 第二幕：为什么要"边发边听"？神秘的【最小帧长 64 字节】是怎么来的？](#4.2 第二幕：为什么要“边发边听”？神秘的【最小帧长 64 字节】是怎么来的？)
  - [4.3 第三幕：撞车之后怎么办？------"摇骰子退避大法"（随机重发）](#4.3 第三幕：撞车之后怎么办？——“摇骰子退避大法”（随机重发）)
  - [4.4 第四幕：【◎重点掌握】那无线 WiFi 为什么不用这招？（CSMA/CD vs CSMA/CA）](#4.4 第四幕：【◎重点掌握】那无线 WiFi 为什么不用这招？（CSMA/CD vs CSMA/CA）)
  - [4.5 📌 本关重点标记（帮你分配脑力）](#4.5 📌 本关重点标记（帮你分配脑力）)
  - [4.6 🤔 第 4 关随堂小挑战与作业复盘](#4.6 🤔 第 4 关随堂小挑战与作业复盘)
  - - [🔍 作业复盘与解析](#🔍 作业复盘与解析)
- [第五节（第 5 关）：2 楼的聪明管家（MAC 地址、以太网帧与交换机自学习）](#第五节（第 5 关）：2 楼的聪明管家（MAC 地址、以太网帧与交换机自学习）)
- - [5.1 第一幕：网卡娘胎里带出来的身份证 ------ MAC 地址](#5.1 第一幕：网卡娘胎里带出来的身份证 —— MAC 地址)
  - - [🔗 顺手揭晓一个惊天伏笔：为什么以太网规定正文最少要塞够 46 字节？](#🔗 顺手揭晓一个惊天伏笔：为什么以太网规定正文最少要塞够 46 字节？)
  - [5.2 第二幕：聪明管家登场 ------ 交换机（Switch）是怎么偷偷记笔记的？](#5.2 第二幕：聪明管家登场 —— 交换机（Switch）是怎么偷偷记笔记的？)
  - - [🎬 第一秒：电脑 A（从 1 号口）给电脑 B 发了一封信 ` $发件人:A -\> 收件人:B$ `](#🎬 第一秒：电脑 A（从 1 号口）给电脑 B 发了一封信 [发件人:A -> 收件人:B])
    - [🎬 第二秒：电脑 B（从 2 号口）给电脑 A 回了一封信 ` $发件人:B -\> 收件人:A$ `](#🎬 第二秒：电脑 B（从 2 号口）给电脑 A 回了一封信 [发件人:B -> 收件人:A])
  - [5.3 第三幕：交换机带来的降维打击 ------ 彻底消灭"吵架屋"！](#5.3 第三幕：交换机带来的降维打击 —— 彻底消灭“吵架屋”！)
  - [5.4 🎬 第三章（数据链路层）网课辅助建议](#5.4 🎬 第三章（数据链路层）网课辅助建议)
  - [5.5 🤔 第三章终极通关 Boss 测试与答案解析](#5.5 🤔 第三章终极通关 Boss 测试与答案解析)
  - - [题目 1：【以太网帧解剖题】](#题目 1：【以太网帧解剖题】)
    - [题目 2：【交换机小本本推演题】](#题目 2：【交换机小本本推演题】)
    - [题目 3：【数房间终极必考题】](#题目 3：【数房间终极必考题】)
- [第六节：📝 复习心得与大白话核心笔记（考前速查）](#第六节：📝 复习心得与大白话核心笔记（考前速查）)

🗺️ 开启第三章：爬上 2 楼数据链路层（互动闯关目录）

现在，我们正式从 1 楼（物理层）顺着楼梯爬上 2 楼：数据链路层（Data Link Layer）！

这一章是计算机网络的第一个重头戏，一共分为 5 个关卡，一环扣一环：

第 1 关 ：1 楼传上来一串停不下来的 0101，2 楼怎么看出哪儿是信的开头、哪儿是结尾？（封装成帧与透明传输）
第 2 关：信在路上被雷劈坏了一个数字，怎么一眼查出来？（差错检测：奇偶校验与 CRC 循环冗余校验）
第 3 关：发出去的信万一丢了，怎么靠"排号重发"来兜底？（流量控制与可靠传输：停止-等待、GBN、SR 滑动窗口）
第 4 关：几台电脑共用一根线或共用 WiFi，怎么防撞车？（CSMA/CD 与 CSMA/CA 协议）
第 5 关：2 楼的终极神器------交换机（Switch）是怎么消灭"吵架屋"的？（MAC 地址与交换机自学习）

第一节（第 1 关）：给信封插上"头尾小红旗"（封装成帧与透明传输）

1.1 第一幕：永不停歇的豆子传送带（为什么要"封装成帧"？）

现在你是 2 楼（数据链路层）的卸货员。

1 楼的苦力电工顺着电线，源源不断地给你传上来一长串 0 和 1 的数字豆子：

text 复制代码

1楼传上来的豆子流： ... 0 1 0 1 1 0 0 1 1 1 0 1 0 0 1 0 1 1 ...

看着这串永不停歇的豆子，2 楼卸货员当场傻眼了：

"这特么从哪颗豆子开始是第 1 封信？到哪颗豆子结束？万一我从中间切错了位置，把张三的信屁股和李四的信脑袋拼在了一起，岂不是全乱套了？！"

怎么解决这个切分问题？

生活里最简单的办法就是：插小红旗（加括号）！

发货方在每封信的最前面插一面 [头旗] ，在最后面插一面 [尾旗] 。这样把原来的包裹前后一夹，打包出来的东西，在 2 楼就叫一个 帧（Frame）。

text 复制代码

           +--------+----------------------------+--------+
一个"帧" =  | [头旗]  |      真正的信件内容          | [尾旗]  |
           +--------+----------------------------+--------+
             (帧首部)         (数据部分)            (帧尾部)

收货员只要看到 [头旗]，就开始往袋子里装豆子；一看到 [尾旗]，就"咔嚓"一刀封口！完美！

1.2 第二幕：突发乌龙事件！信里居然画着一面"假尾旗"！

插小红旗的办法看似完美，但第二天就出了一个大乌龙。

假设我们规定，用一串特殊的代号 EOT 当作 [尾旗]（代表 End Of Transmission，这封信到此结束）。

结果有一天，你在电脑上用 C++ 写了一篇讲解网络的笔记发给朋友，你写的正文内容里，刚好出现了 EOT 这三个字母！

你看下面这幅灾难现场：

text 复制代码

                【你真正想发的一整封信】
+------+--------------------+-------+--------------------+------+
| 头旗  | 前半截正文："所谓    |  EOT  |  就是结束的意思"      | 尾旗 |
+------+--------------------+-------+--------------------+------+
                                ↑
                    2楼卸货员看到这里当场切刀！
           "报告老板！看到 EOT 了！信收完了！后面的全扔掉！"

卸货员是个死脑筋，他看到你正文里的那个 EOT，误以为是真正的 [尾旗] 到了，直接一刀把你的信腰斩了！后半截"就是结束的意思"直接被当成垃圾扔掉了！

怎么才能让你不管在信里写什么奇葩内容（哪怕把头旗、尾旗画在信里），2 楼都能像"透明玻璃"一样看不见它们、绝不误切呢？

这就叫 【★核心必透】透明传输（Transparent Transmission）。

为了解决这个乌龙，工程师们发明了两个绝妙的"防误切魔法"：

1.3 魔法一：贴"免死金牌" ------ 字符填充法（字节填充）

这个办法，写过 C++ 代码的你一眼就能笑出来------因为你早就用过了！

在 C++ 里，字符串是用双引号括起来的，比如 "Hello"。如果你想在字符串正中间打印一个真正的双引号，直接写 "He said "Hello"" 编译器就会报错（误以为字符串提前结束了）。你是怎么干的？

你在中间的双引号前面加了一个 反斜杠 \（转义字符） ，写成了 "He said \"Hello\""！

2 楼的工程师直接抄了这个作业！

他们制作了一块叫 ESC（转义字符） 的"免死金牌"，立下两条死规矩：

发货前先安检 ：发货员在把信封口之前，先把正文从头到尾扫一遍。只要发现正文里出现了长得像 [头旗] 或 [尾旗] 的假货，立刻在它正前方贴上一块 [ESC] 免死金牌！
万一正文里本来就有免死金牌呢？ 如果你的正文里本来就写了 ESC 这三个字，为了防止卸货员把它当成免死金牌，就在它前面**再贴一块 [ESC]**！

你看下面这张安检前后的对比图：

text 复制代码

【安检前：你的原始正文里有假尾旗、假头旗，甚至还有个真ESC】
+------+----------+--------+--------+-------+--------+------+
| 头旗  |  正文A   | 假尾旗  |  正文B  |  ESC  | 假头旗  | 尾旗 |
+------+----------+--------+--------+-------+--------+------+
                       ↓                ↓        ↓
            (全部在前面强行塞入一块 [ESC] 免死金牌！)
                       ↓                ↓        ↓
【安检后：真正在网线上跑的模样】
+------+-------+---------------+-------+-------------+---------------+------+
| 头旗  | 正文A |  [ESC]  假尾旗 | 正文B  | [ESC]  ESC  | [ESC]  假头旗  | 尾旗  |
+------+-------+---------------+-------+-------------+---------------+------+

当收货员收到这封信时：

他每看到一块 [ESC] 免死金牌，就把这块金牌撕掉扔进垃圾桶 ，然后闭着眼睛把紧跟在后面的那个东西当成普通正文放行，绝不切刀！
直到最后看到那个前面没有金牌保护的真 [尾旗]，才咔嚓一刀结束！

1.4 魔法二：逢五塞零大法 ------ 零比特填充法（全网最聪明的小把戏）

刚才的"贴免死金牌"每次都要塞一整个字节（8 个比特），有些抠门的工程师还是嫌太占地方。于是他们发明了更极致、也是考试最爱考的 【★核心必透】零比特填充法（Bit Stuffing）。

怎么干的呢？只用两句话就能讲透：

定一个独一无二的旗帜 ：规定不管是 [头旗] 还是 [尾旗]，统一写成固定的一串数字：01111110 （注意看中间：整整齐齐 6 个连续的 1！）。
立下"不准出现 6 个 1"的天条 ：
既然真旗帜里有 6 个连续的 1 ，那我就绝对不允许你的信件正文里出现 6 个连续的 1！
怎么阻止你出现？

发货时（逢 5 个 1 就强行塞个 0） ：发货员盯着你的正文豆子看，只要数到你连续出现了 5 个 1（11111） ，不管你第 6 个豆子本来是 0 还是 1，发货员立刻霸道地在后面强行塞进去一个假豆子 0！
收货时（逢 5 个 1 就把后面的 0 抠掉） ：收货员在拆信时，只要在正文里数到连续 5 个 1，他就看一眼紧跟着的下一颗豆子：
如果下一颗是 0 ：说明肯定是发货员强行塞进来的假豆子，直接把这个 0 抠掉扔进垃圾桶，完美还原你的原信！
如果下一颗是 10 （连起来凑够了 6 个 1：01111110）：哈哈！说明不是正文，是真正的 [尾旗] 到了！立刻收工！

我们用显微镜看看这颗假豆子是怎么塞进去、又怎么被抠出来的：

text 复制代码

【你的原始正文豆子】：   0 1 1 1 1 1 1 0
                           \_______/
                         数到5个1了！立刻在后面塞个 (0)！
                               ↓
【在网线上跑的豆子】：   0 1 1 1 1 1 (0) 1 0   <-- 原本的6个1被硬生生劈开了！
                                     ↓
【收货员拆信还原】：     数到5个1，把后面的(0)抠掉扔了！
                         还原成：0 1 1 1 1 1 1 0 （跟原来一模一样！）

(注：课本上还会顺带提另外两种凑数的组帧方法，属于 【◎重点掌握】 概念：

字符计数法：不在前后插旗子，而是在信的最开头写个数字"这封信长 10 个字"。这办法极其愚蠢，因为万一开头那个数字在路上被雷劈歪了，变成了"这封信长 99 个字"，后面所有的信就全切错位置了，所以没人用。
违规编码法 ：还记得上一章的曼彻斯特编码吗？它规定正中间必须"从高跳低"或"从低跳高"。如果我故意在正中间 不跳（一直高高平躺、或者一直低低平躺） ，这种平时绝对算违规的动作，刚好可以拿来当 [头旗] 和 [尾旗]，连塞假豆子都省了！)

1.5 📌 本关重点标记（帮你分配脑力）

【★核心必透】透明传输的两种实现计算（必做题型）：

字节填充（字符填充） ：看到正文里有 FLAG（头尾旗） 或 ESC（转义符），就在它前面加一个 ESC。
零比特填充 ：记住旗帜是 01111110（6 个 1）。发送时：每遇到连续 5 个 1，无脑在后面插入一个 0；接收时：每遇到连续 5 个 1，把紧跟在后面的那一个 0 删掉。

1.6 🤔 第 1 关随堂小挑战与作业批改纠偏

这两道小手工题是所有计算机网络考试的必考送分题：

【塞豆子练习（发送方）】 ：
假设你要发送的一段原始正文比特串是：0 1 1 1 1 1 0 0 1 1 1 1 1 1 1 0 。
现在采用零比特填充法 ，请你当一回发货安检员，在上面这串数字里找出所有连续满 5 个 1 的地方，塞入 0，写出最终发到网线上的比特串长什么样？（可以用括号 (0) 标出塞进去的假豆子）。
【抠豆子练习（接收方）】 ：
现在你变成了收货员，从网线上收到了一段已经经过零比特填充的正文：1 1 1 1 1 0 1 1 1 1 1 0 0 。
请你把里面被发货员塞进去的假 0 抠掉，还原出朋友真正想发给你的原始比特串！

🔍 作业批改与纠偏（极易踩坑点！）

第 2 题（收货员抠豆子）：完全正确！
收到的串：1 1 1 1 1 0 1 1 1 1 1 0 0
拆解：数到前 5 个 1，把紧跟的第 1 个 0 抠掉；接着又数到 5 个 1，把紧跟的第 2 个 0 也抠掉，只留下最后那个真 0。
还原结果：1 1 1 1 1 1 1 1 1 1 0 （10 个 1 加 1 个 0），一分不差！
第 1 题（发货员塞豆子）：注意后半段千万别漏塞 0！
把原始正文拉出来看：0 1 1 1 1 1 0 0 1 1 1 1 1 1 1 0。
前半段 ：0 1 1 1 1 1 满 5 个 1 了，塞了一个 (0)，变成 0 1 1 1 1 1 (0) 0 0。
后半段极易漏掉的危险分子 ：后面紧跟着的那一串是 1 1 1 1 1 1 1 0（连续 7 个 1！） 。如果直接放行，网线上就会出现连续 7 个 1，对面的收货员数到第 6 个 1 时，就会误以为是 [尾旗]（01111110），当场把信一刀咔嚓切掉！
正确的安检动作 ：安检员的计数器是循环工作 的。在后半段数满前 5 个 1 时，必须再次立刻塞入一个 (0) ，然后把剩下的 1 1 0 接在后面：

text 复制代码

原始后半段：   1 1 1 1 1   1 1 0
               \_______/
             又满5个1了！必须再塞个(0)！
                   ↓
正确结果：0 1 1 1 1 1 (0) 0 0 1 1 1 1 1 (0) 1 1 0

铁律总结 ：不管后面还有多少个 1，只要计数器数满 5 个，就无脑塞一个 0，然后计数器归零重新往下数！

第二节（第 2 关）：给信封贴上"防伪封条"（奇偶校验与 CRC）

现在，我们的信已经安全装进"帧（Frame）"里，插好了头尾小红旗，再也不会被切错位置了。

接下来，卡车拉着这个帧驶上了 1 楼那条破破烂烂的铜线马路。半路上突然一道闪电劈在网线旁边！这引出了我们的第 2 关：信在路上被雷劈坏了一个数字，怎么一眼查出来？（差错检测）

2.1 第一幕：一道闪电引发的惨案

卡车在网线上狂奔时，旁边突然打了个雷（电磁干扰）。

你原本发出去的正文是 1 0 1 0 ，结果被雷电一震，最后一个数字 0 被硬生生震翻成了 1 ，送到朋友手里变成了 1 0 1 1 （在黑话里，1 变成 0 或者 0 变成 1，叫 比特差错）。

朋友的 2 楼卸货员拿着这封被雷劈过的信，他怎么知道里面有颗豆子变质了呢？

为了抓出变质的豆子，工程师们先后发明了两种"防伪封条"，贴在每一帧的【帧尾部】。

2.2 防伪封条一：初学者的笨办法 ------ 奇偶校验码（Parity Check）

这个办法特别像幼儿园老师点名，规则简单到令人发指：

发货前，你和朋友提前约好加入"双数俱乐部"（偶校验）------意思是：不管信里写了啥，整封信里所有 1 的个数加起来，必须凑成双数（偶数）！

怎么凑呢？发货员在信的最后面，留一个专门放"凑数豆子"的空位：

情况 A ：你要发的正文是 1 0 1 1 0 。发货员一数："哎呀，里面有 **3 个 1**，是单数！"为了凑成双数，发货员就在最后面塞一颗 [1] ，变成 1 0 1 1 0 [1] （现在一共 4 个 1，凑成双数了！）。
情况 B ：你要发的正文是 1 0 1 0 0 。发货员一数："里面有 2 个 1 ，本来就是双数！"那就不用凑了，直接在最后面塞一颗 [0] ，变成 1 0 1 0 0 [0] （依然是 2 个 1，保持双数！）。

(反之，如果你们约定把 1 的总数凑成单数，就叫"奇校验"，道理一模一样。)

现在，这封信 1 0 1 1 0 [1] （4 个 1）上路了！

如果半路被雷劈坏了 1 颗豆子 （比如第 1 个 1 变成了 0），送到朋友手里就变成了：

text 复制代码

朋友收到的信：  0  0  1  1  0  [1]
               ↑ (这颗1被雷劈成了0！)
               
朋友开始数 1 的个数： 1个、2个、3个...... 怎么只有 3 个 1（单数）？！
朋友当场拍案而起："抓到了！我们约好是双数的，路上绝对被雷劈了！扔进垃圾桶！"

🚨 可是，这个笨办法有一个致命的死穴！

万一那道闪电威力比较大，一口气同时劈坏了 2 颗豆子 呢？（比如把两个 1 同时劈成了 0）。

原本有 4 个 1 ，死了两个，还剩 2 个 1 ------2 居然还是双数！

朋友一数："嗯，2 个 1，是双数，没毛病！"然后开开心心地把这封早就被劈得面目全非的假信收下了！

【◎重点掌握】奇偶校验的致命弱点 ：它只能查出奇数个（1个、3个、5个...）豆子出错；只要同时坏了偶数个（2个、4个...）豆子，它就彻底瞎了，完全查不出来！（漏检率高达 50%）。

2.3 防伪封条二：真正的工业界霸主 ------ CRC 循环冗余校验（【★核心必透】）

既然数单双数太容易被糊弄，2 楼的工程师们请出了数学大神，设计出了现代网络（包括你平时解压 .zip 压缩包报错时）真正在用的终极防伪章------CRC（循环冗余校验）。

别被这六个字吓到！它的核心思想其实就是一个"小学除法算余数"的游戏：

基本脑回路：

假设你想给朋友寄一个大数字 15 。你们俩提前在电话里商量好一个秘密除数，比如 4。

发货前，你拿 15 ÷ 4 15 \div 4 15÷4，算出来商是 3 3 3，余数是 3 。你不在乎商是多少，你只把余数 [3] 当成防伪印章，盖在信封尾巴上，跟着 15 一起寄出去。

朋友收到数字后，也拿秘密除数 4 去算余数。如果路上 15 被雷劈成了 16 或 17，除以 4 的余数肯定不再是 3 了！除非闪电恰好凑巧把数字劈成了 4 的整数倍差值，否则根本逃不过法眼！

那么在电脑里，只有 0 和 1，是怎么算这个"余数防伪章"的呢？

跟着做一遍下面这个"三步走消消乐游戏"（这是考研必考的手工计算题，学会了白捡分）：

🎲 游戏准备：

你要发的原始数据是：1 0 1 0
你和朋友约好的秘密除数是：1 1 0 1（共 4 位数）

第一步：看除数有几位，就在数据屁股后面补几个 `0`（少补一个）

秘密除数 1 1 0 1 一共有 4 位 ，我们就用 4 − 1 = 3 4 - 1 = 3 4−1=3，在原始数据屁股后面先占 3 个空位（补 3 个 0），用来待会儿填余数：

变成：1 0 1 0 0 0 0

第二步：玩"相同为 0，不同为 1"的消消乐除法（模 2 除法）

在电脑里做二进制除法，不需要借位，也不比大小！规则极其痛快：

只要最左边打头的数字是 1 ，就把除数 1 1 0 1 摆在下面对齐；
然后上下两行数字一对一比较：上下长得一样就写 0，长得不一样就写 1（这就是你写 C++ 里的异或 ^ 运算！）。

你看下面这张竖式图，顺着箭头往下看，比小学减法还简单：

text 复制代码

          1 1 0 1         <-- 商（写完直接无视，我们只要最底下的余数！）
        -----------------
1 1 0 1 ) 1 0 1 0 0 0 0   <-- 第1步补完三个0的数据
          1 1 0 1         <-- 打头是1，摆上除数 1101，上下比对(相同为0，不同为1)
          -------
            1 1 1 0       <-- 比完剩下 111，把上面的第1个 0 拉下来，变成 1110
            1 1 0 1       <-- 打头还是1，继续摆上 1101 上下比对！
            -------
              0 1 1 0     <-- 比完开头变成了 0！注意：打头是0不能摆除数(相当于商0)，
                              直接把最前面的0消掉，再从上面拉个 0 下来！
                1 1 0 0   <-- 拉下来后变成 1100，打头又是1了！摆上 1101 比对！
                1 1 0 1
                -------
                  0 0 1   <-- 上面的0全拉完了！最后剩下的这3位数【0 0 1】就是余数！

第三步：把算出来的余数，填进第一步补的 `0` 里面！

刚才第一步我们在 1 0 1 0 后面补了三个零 0 0 0，现在把滚烫出炉的 3 位余数 0 0 1 替换进去！

最终发上网线的完整包裹就是：1 0 1 0 [0 0 1] ！（后面这个 [0 0 1] 在帧尾部里就叫 FCS 帧检验序列）。

当朋友收到 1 0 1 0 0 0 1 时怎么验货？

朋友直接拿这整串数字除以秘密除数 1 1 0 1（做同样的消消乐）。

如果最后算出来的余数是 全 0（0 0 0） → \rightarrow → 说明一滴都没错，完美收货！
如果算出来的余数不是 0 → \rightarrow → 说明路上被雷劈了，二话不说直接扔进垃圾桶！

2.4 📌 本关重点标记（帮你分配脑力）

【★核心必透】2 楼发现信坏了之后，会帮着修好吗？（检错 vs 纠错）
绝对不会修！直接扔垃圾桶！
在有线局域网（比如以太网）的 2 楼，CRC 只负责"检错（查出有错）"，绝不负责"纠错（把错位改回来）"。因为找出来到底是第几个豆子坏了成本太高，直接把坏帧丢弃，等楼上的 4 楼（TCP）发现丢包后重发一遍，反而快得多！
【★核心必透】CRC 竖式计算小技巧：

题目有时候不直接给你写除数 1101，而是装神弄鬼写个多项式 G ( x ) = x 3 + x 2 + 1 G(x) = x^3 + x^2 + 1 G(x)=x3+x2+1 。你别怕，这只是把有 x x x 的次方位置写成 1，没有的次方写成 0： 1 ⋅ x 3 + 1 ⋅ x 2 + 0 ⋅ x 1 + 1 ⋅ x 0 → 1 \cdot x^3 + 1 \cdot x^2 + 0 \cdot x^1 + 1 \cdot x^0 \rightarrow 1⋅x3+1⋅x2+0⋅x1+1⋅x0→ 就是 1 1 0 1 ！（最高次方是 3 3 3，就代表要在数据后面补 3 个 0）。
消消乐口诀："相同为 0，不同为 1；打头是 1 摆除数，打头是 0 往下滑"。

【○有个概念即可】海明码（Hamming Code） ：
教材里还会提一个能"不仅查出错，还能定位哪一位错并改回来"的纠错码叫海明码。记住一个不等式口诀 2 r ≥ k + r + 1 2^r \ge k + r + 1 2r≥k+r+1 （ k k k 是原始数据位数， r r r 是要塞进去的防伪豆子位数）即可，在计算机组成原理里它考得多，在计网里知道它是"纠错码"就行。

2.5 🤔 第 2 关随堂小挑战与作业复盘

【双数俱乐部抓内鬼（偶校验）】 ：
你和朋友约定了使用偶校验 （整串数字里 1 的总个数必须是双数）。现在你收到了朋友发来的三个包裹：

包裹 A：1 1 0 1 0 [1]
包裹 B：1 0 1 1 0 [0]
包裹 C：0 0 0 0 0 [0]
请问：哪一个包裹一定在路上被雷劈坏了？另外两个没报错的包裹，就 100% 绝对没被雷劈过吗？为什么？

【消消乐热身（CRC 核心动作）】 ：
假设在算 CRC 竖式时，上面一行数字是 1 0 1 1 ，下面摆上的除数是 1 1 0 1。按照"相同为 0，不同为 1"的规矩，请你写出它们俩比对消消乐之后，底下算出来的 4 位结果是多少？

🔍 作业复盘与解析

偶校验抓内鬼 ：包裹 B 中有 3 个 1（奇数），违反了偶校验规则，一定在路上损坏了；包裹 A（4 个 1）和包裹 C（0 个 1，0 也是偶数）虽然通过了检查，但不能 100% 保证没被雷劈过 ------如果在路上恰好同时被雷劈坏了 2 个或 4 个（偶数个） 数字，偶校验是查不出来的。
CRC 消消乐 ：1 0 1 1 与 1 1 0 1 按位比对（相同为 0，不同为 1），结果正是 0 1 1 0。

第三节（第 3 关）：扔砖头过河的艺术（流量控制与可靠传输：停止-等待、GBN、SR）

顺着上一关的结尾，我们遇到了一个火烧眉毛的新危机：

当朋友的 2 楼收货员用 CRC 算出来余数不对，发现信被雷劈坏了，他二话不说直接把坏信扔进了垃圾桶 ！

可是，远在北京的你正坐在家里喝茶呢，你根本不知道信被扔进了垃圾桶，还在傻乎乎地以为朋友已经收到了！

怎么让丢了的信能自动补发？如果发信的人手速太快、收信的人屋子太小装不下，怎么让发信人慢一点？

这就是我们要闯的 第 3 关：从"一问一答"到"流水线批发"（停止-等待、GBN、SR）。

(注：【○有个概念即可】 在现在的有线局域网（比如插网线的以太网）里，因为铜线质量很好很少出错，2 楼其实很懒，扔掉坏信后自己不管，全推给 4 楼的 TCP 去重发；但在无线网（WiFi）里，空气干扰太大，2 楼就必须亲自负责重发。而且不管是 2 楼还是 4 楼，它们实现重发和控速的底层武功是完全通用的，就是下面这三个绝招！)

3.1 第一幕：最老实的笨办法 ------ 停止-等待协议（Stop-and-Wait）

想象一下，你在河左边，朋友在河右边。你要隔着河把一车砖头扔给他盖房子。

为了保证每一块砖都安全落到他手里，而且不砸晕他，最稳妥的办法是什么？

扔一块，停下来，等他喊"收到"，再扔下一块！

text 复制代码

[你] ──(1) 扔出【砖头】────────────────────> [朋友] (接住！)
[你] <─(2) 喊话【确认收到 (ACK)】─────────── [朋友]
(听到喊话后，你才弯腰捡起下一块砖头...)

(在计网黑话里，朋友喊的那句"收到"，叫做 ACK 确认帧。)

这听起来像小学生过家家一样简单。但如果河面上刮起了大风，就会出现 两种要命的意外：

意外 1：砖头半路掉进河里了（数据丢失 / 出错被扔掉）

你把砖头扔出去，结果扑通掉水里了。对面的朋友根本没看到砖头，自然也不会冲你喊"收到"。

你在左岸干等......等一辈子吗？不行！

解决办法（定个闹钟） ：你每次扔出砖头的瞬间，就在手腕上按响一个 倒计时闹钟（超时计时器） ，比如定 5 秒钟。如果 5 秒钟过去了，河对面一点声音都没有，闹钟"叮铃铃"一响，你就默认砖头掉河里了，立刻拿出一块一模一样的备份砖头，重新扔一次（超时重传）！

意外 2（极其阴险！）：砖头安全到了，但朋友喊的"收到"被大风吹跑了！（ACK 丢失）

请集中注意力看下面这幅慢动作画面，这是所有初学者第一次学必踩的大坑：

text 复制代码

1. [你] ── 扔出【第1块砖】 ────────────────> [朋友] (稳稳接住！拿去砌墙了！)
2. [你] <──── (半路被狂风吹散！) ── 喊"收到" [朋友]
3. [你] (闹钟响了！以为砖头掉河里了，又拿出一块一模一样的【第1块砖】扔过去！)
4. [你] ── 重扔【第1块砖】 ────────────────> [朋友] (？？？)

你看第 4 步！

朋友刚才明明已经接住第 1 块砖砌到墙上了。现在因为他的喊话被风吹跑，你误以为他没收到，把第 1 块砖又扔了一遍 ！

如果砖头上没有任何标记，朋友接住这第二块飞过来的砖头时，会怎么想？

他会以为："哇，这是你扔过来的【第 2 块新砖头】！" 于是他把两块一模一样的砖头全砌到了墙上（你的微信聊天框里就会莫名其妙蹦出两句重复的"你好""你好"）！

怎么破局？

【★核心必透】给砖头和喊话都编上号！
在停止-等待协议里，根本不需要从 1 编到 100，只需要交替用 0号 和 1号 两个贴纸就够了！
你先扔 [0号砖]；
如果朋友刚才已经收过 [0号砖] 了，现在正在等 [1号砖]，结果看到天上飞过来的居然还贴着 [0号砖]！
朋友一眼就看穿了真相："哈哈，这是块重复的旧砖头！肯定是我刚才喊的收到被风吹跑了！"
于是朋友做出两个标准动作：1. 把这块重复的 [0号砖] 直接扔进河里（丢弃重复帧）；2. 赶紧再冲你大喊一声"收到 0 号啦！"（重发 ACK），免得你的闹钟一直响个不停！

3.2 第二幕：停止-等待太慢了！开启"滑动窗口"流水线！

"扔一块、等一声"虽然稳如老狗，但它有一个让人抓狂的缺点：太慢了！

假设你扔一块砖只需要 1 秒钟 ，但砖头在河面上飞过去要 10 分钟 ，朋友的声音传回来又要 10 分钟。那你每工作 1 秒钟，就要坐在岸边傻等 20 分钟！一天下来根本搬不了几块砖（信道利用率极低）。

怎么把河面空间彻底利用起来？

不要等！一口气连着往空中扔一排砖头！

但是，你也不能疯了一样一口气扔 1 万块砖，不然对面的朋友接不过来会被砸死。

于是你们俩商量好一个"限额框（发送窗口）"，比如框的大小是 4 。意思是：在没听到朋友喊"收到"之前，你最多可以一口气连着往天上扔 4 块砖（0号、1号、2号、3号）！

text 复制代码

      【你的备货区：滑动窗口（限额4块）】
  [已确认] | 【 0号 | 1号 | 2号 | 3号 】 | 4号  5号  6号 (框外的还不准扔！)
               \____ 连着扔出去！____/

只要对面传来一声："0号收到啦！"，你这个"限额 4 块"的木框就往右滑动一格 ，把 0号 踢出框外，把后面的 4号 圈进框里，你就可以紧接着把 4号 扔出去了！

这就是全网鼎鼎大名的 【★核心必透】滑动窗口机制（Sliding Window）！

流量控制（防砸死） ：如果朋友觉得手忙脚乱接不过来了，他就冲你喊："把你的木框缩小成 2 格！"你就老老实实少扔点，这就叫流量控制。

3.3 第三幕：半路掉了一块砖！两兄弟反目成仇（GBN vs SR）

现在，高潮来了！

你一口气连着扔出了 0号、1号、2号、3号 共 4 块砖。

结果天有不测风云：

0号砖：安全到达！
1号砖 ：扑通！半路掉进河里了！
2号砖、3号砖：紧随其后，安全飞到了朋友面前！

text 复制代码

[你] ──> 扔出 3号、2号、1号(掉河里了💥)、0号 ──> [朋友面前飞来了：0号、2号、3号]

面对"中间缺了 1 号，但 2 号和 3 号已经到了"的尴尬局面，对面的朋友该怎么处理 2号 和 3号？

这里分裂出了两个脾气完全相反的门派（【★核心必透】考研选择题与大题常客）：

门派 A：强迫症哥哥 ------ 后退 N 帧协议（GBN，Go-Back-N）

哥哥是个极端死板的强迫症，他手里没有多余的篮子，一次只能按顺序收一块砖 （接收窗口大小 = 1 = 1 =1）。

他接住 0号 后，心里死死念叨："我接下来只收 1号！只收 1号！"
这时候，2号 和 3号 飞到了他怀里。哥哥看了一眼："呸！我要的是 1 号，你们 2 号、3 号来凑什么热闹？！"
他居然把好不容易安全飞过来的 2号 和 3号 当场一脚全踢进河里扔掉了！ 然后冲着左岸扯着嗓子不停地喊："我只收到了 0 号（ACK 0）！我只收到了 0 号（ACK 0）！"
左岸的你一看 1号 的闹钟响了，既然 2号、3号 也被那家伙踢进河里了，你只能欲哭无泪地往后退回去（Go Back），把 1号、2号、3号 全部重新扔一遍！
哥哥的优缺点：朋友那边特别省钱（不需要买大篮子存乱序的砖），但一旦河面上风浪大经常掉砖，后面排队的无辜好砖全跟着陪葬，白白重扔一大堆！
哥哥的一个省事小习惯（累积确认） ：如果 0、1、2、3 全都安全到了，哥哥不需要喊四声，他只需要偷懒喊最后一声："3号及以前的我全收到啦！" （这叫累积确认，哪怕前面喊的"收到1号"、"收到2号"在半路被风吹跑了也完全不需要重传，只要最后的"收到3号"传过去，你就知道 0、1、2、3 全齐了！）。

门派 B：收纳狂弟弟 ------ 选择重传协议（SR，Selective Repeat）

弟弟看着哥哥把好端端的 2号、3号 踢进河里，心疼得直拍大腿："哥你是不是傻！人家好不容易飞过来的，先存起来不行吗？！"

于是，弟弟在自己身边摆了一个带格子的储物架 （接收窗口 > 1 > 1 >1）：

1号 掉河里了，但 2号 和 3号 飞过来了。弟弟笑眯眯地把 2号 和 3号 接住，先放在储物架的第 2 格和第 3 格里收好，并冲你喊："2号收到！3号收到！"
等到你左岸 1号 的闹钟响了，你只需要单独补扔一块 1号砖（选择重传）！
弟弟接住补发的 1号砖 后，跟储物架上的 2号、3号 拼成整整齐齐的 1、2、3，一口气端上楼交差！
弟弟的优缺点：绝不浪费任何一块好砖（只重传真正坏掉的那一块），但弟弟必须在岸边花钱买一个大储物架（接收方需要缓存空间）。

3.4 📌 本关重点标记（帮你分配脑力）

【★核心必透】三种协议的灵魂对比表：

协议名称	发送木框（发送窗口）大小	朋友的篮子（接收窗口）大小	中间丢了 1 号，后面的 2 号、3 号怎么办？
停止-等待	= 1 = 1 =1（扔一块等一下）	= 1 = 1 =1	根本还没扔 2 号和 3 号呢
后退 N 帧 (GBN)	> 1 > 1 >1（连着扔一排）	= 1 = 1 =1（死板强迫症）	2 号、3 号全踢进河里扔掉，左岸被迫把 1、2、3 全重扔一遍
选择重传 (SR)	> 1 > 1 >1（连着扔一排）	> 1 > 1 >1（有储物架）	2 号、3 号先存上储物架，左岸只单独补扔 1 号即可

【◎重点掌握】木框（窗口）最大能造多大？（防贴纸不够用公式） ：
如果砖头上的编号贴纸是用 n n n 个比特 写的（比如 n = 2 n=2 n=2，那总共只有 00(0)、01(1)、10(2)、11(3) 共 2 2 = 4 2^2 = 4 22=4 种编号贴纸可以循环贴）。
如果木框造得太大，把 4 种贴纸一口气全扔出去，万一对面回喊的 ACK 全被风吹跑了，你把旧的 0~3号 重扔过去时，朋友的窗口已经滑到了下一轮的 0号，就会彻底分不清飞过来的是新砖还是上一轮重传的旧砖！所以必须满足核心通用不等式：

发送窗口 W T + 接收窗口 W R ≤ 2 n \text{发送窗口 } W_T + \text{接收窗口 } W_R \le 2^n 发送窗口 WT+接收窗口 WR≤2n

在 GBN 里（ W R = 1 W_R = 1 WR=1） ：发送木框最大只能是 2 n − 1 2^n - 1 2n−1 （比如 4 种贴纸，木框最大是 4 − 1 = 3 4 - 1 = 3 4−1=3）。
在 SR 里（ W T = W R W_T = W_R WT=WR） ：发送木框和接收储物架一般一样大，最大只能占贴纸总数的一半：2 n − 1 2^{n-1} 2n−1 （比如 4 种贴纸，木框最大是 4 ÷ 2 = 2 4 \div 2 = 2 4÷2=2）。

3.5 🤔 第 3 关随堂小挑战与作业复盘

【停止-等待抓虫题】 ：
在停止-等待协议里，你扔出了 [0号砖]，朋友稳稳接住了，并冲你喊了声 收到0号。结果这声喊话在半路被风吹跑了。5 秒后你的闹钟响了，你又重扔了一块 [0号砖]。
请问：当朋友看到这块重复飞过来的 [0号砖] 时，他除了要把这块砖扔掉之外，还必须不厌其烦地再冲你喊一声 收到0号 吗？如果他嫌烦闭嘴不喊，会发生什么恐怖的事情？
【强迫症哥哥 GBN 实战题】 ：
假设你们用 GBN（后退 N 帧） 协议，你一口气连着扔出了 0号、1号、2号、3号、4号 共 5 块砖。结果倒霉催的，2号砖 在半路掉河里了，其余的 0、1、3、4 全都飞到了强迫症哥哥面前。
请问：哥哥最终只收下了哪几块砖？你待会儿闹钟响了，一共需要把哪几块砖重新扔一遍？
【公式秒杀题】 ：
如果砖头上的编号贴纸是用 3 个比特 写的（也就是总共有 2 3 = 8 2^3 = 8 23=8 种编号：0~7）。请问在 GBN 协议里，你的发送木框最多能装几块砖？在 SR 协议里，最多能装几块砖？

🔍 作业复盘与细节修正

第 1 题（准确） ：朋友收到重复的 0号砖 时，虽然把砖扔了，但必须再喊一声 收到0号 。如果不喊，左岸的你闹钟一响又会重扔 0号砖，两个人就卡在 0号砖 上死循环了。
第 2 题（审题细节纠偏）：

注意看清题目写的是 "倒霉催的，2号砖 在半路掉河里了，其余的 0、1、3、4 飞到了哥哥面前" （掉进河里的是 2号 ，不是故事里举例子时的 1号）。
既然 0号 和 1号 都按顺序安全飞到了哥哥手里，强迫症哥哥自然会开开心心地把 0号 和 1号 都收下 ！他是直到等 2号 没等来、却迎面撞见 3号 和 4号 时，才把 3号 和 4号 踢进河里的。所以你最后只需要重扔 2、3、4 这三块砖！

第 3 题（准确） ：3 个比特一共有 2 3 = 8 2^3 = 8 23=8 种编号。GBN 最大发送窗口是 8 − 1 = 7 8 - 1 = \mathbf{7} 8−1=7，SR 最大发送窗口是 2 3 − 1 = 4 2^{3-1} = \mathbf{4} 23−1=4。

第四节（第 4 关）：大黑屋里的"抢话潜规则"（CSMA/CD 与最小帧长之谜）

现在，我们进入数据链路层最精彩、也最考验物理直觉的一关。

还记得在 1 楼结尾，我们把 4 台电脑插在同一个集线器（或者连在同一根总线上）吗？只要有两台电脑同时说话，电流就会在电线里迎头相撞，撞成一团废码。

怎么在没有管理员的情况下，靠大家自觉遵守规矩来防撞车？工程师们发明了统治早期有线局域网的著名协议------【★核心必透】CSMA/CD（载波监听多点接入 / 碰撞检测）。

别背这串拗口的名字，它的灵魂只有 16 个大白话口诀：

"先听后发，边发边听，碰撞停发，随机重发"

我们把这 16 个字拆成三个惊心动魄的慢动作现场，你就彻底看懂它的设计精髓了：

4.1 第一幕：为什么"先听后发"还是会撞车？

这 16 个字的前四个字叫"先听后发"：每台电脑张嘴说话前，先把耳朵贴在网线上听一听。如果网线里有别人的电流声（信道忙），就闭嘴等着；如果网线里安安静静（信道空闲），就立刻张嘴发数据。

这时候，一个初学者最容易想不通的问题来了：

"既然大家都是听着没人说话才张嘴的，那怎么可能还会撞车呢？！"

答案全怪我们在第一章学过的那个家伙------传播时延（电信号在网线里跑是需要时间的）！

假设 电脑 A 在网线的最左边，电脑 B 在网线的最右边，电信号从左跑到右需要 10 毫秒（我们把这个单程跑完的时间记作 τ \tau τ）。你看下面这幅慢动作惨剧：

text 复制代码

【第 0 毫秒】：A 贴着网线听，很安静！于是 A 张嘴发出了电信号：
[电脑 A] ──(A的电流刚出发)──>                                   [电脑 B]

【第 9 毫秒】：A 的电流快跑到 B 家门口了，但还差一点点没到！
               此时 B 贴着自己家门口的网线一听："咦？也很安静没人说话呀！"
               于是 B 也放心地张嘴发出了电信号！
[电脑 A] ──────────────────────(A的电流)──>   <──(B的电流)── [电脑 B]

【第 9.5 毫秒】：轰隆！！两股电流在半路迎头相撞！同归于尽！
[电脑 A] ────────────────────────── 💥撞车！💥 ────────────── [电脑 B]

看明白了吗？因为电信号跑过去要花时间，当 A 已经开始说话时，远在天边的 B 根本还没听到 A 的声音，误以为网线空闲也跟着张嘴，悲剧就此发生！

4.2 第二幕：为什么要"边发边听"？神秘的【最小帧长 64 字节】是怎么来的？

既然"先听后发"躲不开半路撞车，那就必须靠第二句口诀："边发边听，碰撞停发" 。

意思是：电脑 A 在往外发数据的同时，耳朵还必须一直贴在网线上听着。一旦撞车，撞碎的残骸电信号会顺着网线反弹回 A 的耳朵里。A 一听到刺耳的碰撞杂音，就知道："坏了！我的信在半路被撞碎了！别白费力气了，赶紧闭嘴停发，省得浪费时间！"

🚨 但是！这里藏着整个数据链路层最核心的一个漏洞（【★核心必透】）！

假设电脑 A 只想给朋友发一个极短极短的字："好！" （只花了 1 毫秒 就说完了）。

说完之后，电脑 A 心满意足地摘下耳机、收工去睡觉了，心里美滋滋地以为："刚才我说话的那 1 毫秒里，耳机里安安静静的，说明这句'好'肯定安全送到了！"

可实际上呢？我们来看最倒霉的极端情况（计算题必考的 2 τ 2\tau 2τ 争用期）：

text 复制代码

|<------------------ 单程最远耗时 τ = 10毫秒 ------------------>|

1. [电脑 A] 在第 0 毫秒说了一句极短的"好"(1毫秒说完，摘耳机睡觉去了💤)
      │
      ├───────────────────────> 跑到最右边快到第 10 毫秒时，B 突然张嘴！💥撞碎了！
                                                            │
2. [电脑 A] (早睡着了，根本不知道！) <──────────────────────────┘
            撞碎的残骸跑回 A 家门口，已经是【第 20 毫秒 (2τ)】了！

请你仔细算算这笔时间账：

A 的电流跑到最右边的 B 家门口，最多要花 1 个单程时间 τ \tau τ（10 毫秒）；
就在即将到达 B 家门口的前一瞬间（第 9.99 毫秒），B 突然张嘴发生撞车！
撞碎的残骸从 B 家门口再跑回 A 的耳朵里，又要花 1 个单程时间 τ \tau τ（10 毫秒）！

也就是说，从 A 张嘴的那一刻算起，最晚要等整整一个来回的时间 ------ 2 τ 2\tau 2τ（20 毫秒） ，A 才能彻底放心："连最远处的 B 都没撞上我，这下绝对安全了！"（这个来回时间 2 τ 2\tau 2τ，在课本里有个专门的名字叫 争用期 / 碰撞窗口）。

如果 A 说话太快，不到 2 τ 2\tau 2τ（20 毫秒）就把话说完并摘下了耳机，那么就算半路撞车了，A 也永远不会知道，更不会去重发！

怎么补上这个漏洞？工程师立下了一条霸道的天条：

"不准说短话！所有人在说话时，必须拉长音，至少要连续说满 2 τ 2\tau 2τ（20 毫秒）的时间，才能闭嘴摘耳机！"

如果你要发的信实在太短，不够说满 2 τ 2\tau 2τ 怎么办？在信的屁股后面强行塞满废话（填充 0），硬生生凑够能说满 2 τ 2\tau 2τ 的长度为止！

这就引出了全网最著名的公式：

最小帧长 = 发送速率（带宽） × 2 τ （往返跑一趟的时间） \text{最小帧长} = \text{发送速率（带宽）} \times 2\tau\text{（往返跑一趟的时间）} 最小帧长=发送速率（带宽）×2τ（往返跑一趟的时间）

在传统的以太网里，科学家们定好规矩：只要你的信凑够了 64 个字节（也就是 512 个比特） ，就一定够说满 2 τ 2\tau 2τ 的时间！

如果你要发的信只有 40 个字节？对不起，2 楼发货员会在后面强行塞入 24 个字节的垃圾填充物 ，凑满 64 字节 才准发上路！
反过来，如果收货员在网线上捡到了一个还不到 64 字节的短命包裹 ，说明什么？说明发货的人说到一半听见撞车、紧急闭嘴停发了！这个短命包裹就是撞车留下的碎尸残骸，收货员连看都不用看，直接当垃圾扔掉！

4.3 第三幕：撞车之后怎么办？------"摇骰子退避大法"（随机重发）

好，现在 A 和 B 在说话期间都听到了撞车的杂音，双双紧急闭嘴了（碰撞停发）。

接下来它们俩都要重发刚才那封信。

可是，如果它们俩闭嘴后，同时数"1、2、3"然后又一起张嘴呢？那不是又要迎头撞上、生生世世死磕到底吗？！

所以最后四个字叫 "随机重发" （黑话叫：【◎重点掌握】截断二进制指数退避算法 ）。

名字很唬人，其实就是"掏骰子摇点数"，越撞车，掏出来的骰子面数越大：

第 1 次撞车（ k = 1 k=1 k=1） ：A 和 B 各自从兜里掏出一枚 2 个面 的硬币（上面写着 0 和 1 ，即 0 ∼ 2 1 − 1 0 \sim 2^1-1 0∼21−1）。
A 摇出了 0（代表不用等，立刻重发！）；
B 摇出了 1（代表老老实实等 1 个 2 τ 2\tau 2τ 的时间再发！）。
哈哈！A 先发走了，等 B 倒计时结束去听的时候，听见 A 正在发，B 就乖乖闭嘴，完美错峰！
万一倒霉，两人第 1 次都摇出了 0，又撞上了呢？（第 2 次撞车， k = 2 k=2 k=2）：
说明 2 个面的硬币不够用了！两人立刻换一个 4 个面 的骰子（上面写着 0, 1, 2, 3 ，即 0 ∼ 2 2 − 1 0 \sim 2^2-1 0∼22−1）再摇！这下撞衫的概率只有四分之一了！
第 k k k 次撞车 ：就换一个写着 0 ∼ ( 2 k − 1 ) 0 \sim (2^k - 1) 0∼(2k−1) 的大骰子来摇！
最多放大到多大？（截断） ：如果连续撞了 10 次以上，骰子最多也就定格在 2 10 − 1 = 1023 2^{10}-1 = 1023 210−1=1023 个面，不再继续变大了。
什么时候彻底死心？ ：如果一封信倒霉透顶，连续撞车了 16 次 还没发出去，网卡就会彻底绝望："外面太堵了，我不发了！"直接把这封信扔掉，并向楼上报告发送失败。

4.4 第四幕：【◎重点掌握】那无线 WiFi 为什么不用这招？（CSMA/CD vs CSMA/CA）

刚才讲的 CSMA/CD（边发边听、撞了再说）是插网线（有线局域网）专用的。
到了无线网（WiFi）里，空气中没有网线，工程师们把最后两个字母改成了 CSMA/CA（把 CD 碰撞检测，改成了 CA 碰撞避免）。

为什么无线 WiFi 不敢玩"边发边听、撞了停发"，而非要战战兢兢地"提前避免碰撞"呢？只有两个大白话原因：

自己的大嗓门把自己震聋了：在空气中发无线电波，离你嘴巴 1 厘米的地方信号极强，而从远方撞车反弹回来的无线电波微弱得像蚊子叫。你一边扯着嗓子喊话，根本听不见空气里微弱的撞车回音（无法做到"边发边听"）！
看不见的第三者（隐蔽站问题）：你看下面这张图------

text 复制代码

[你的手机 A] ──(信号够得着)──> [家里的 WiFi 路由器 B] <──(信号够得着)── [客厅的电脑 C]
      │                                                                   │
      └─────────────── (隔着两堵承重墙，A 和 C 互相听不见对方！) ───────────────┘

你想给路由器 B 发消息，你先竖起耳朵听了一圈，因为隔着墙，你根本听不见客厅里的电脑 C 正在跟路由器 B 说话！于是你一头撞上去，把路由器 B 搞得两头乱码！

所以 WiFi 只能乖乖采用 CA（碰撞避免） ：不仅每次发完必须等路由器回一句"收到（ACK）"，而且在发大文件前还可以先举手喊一句 "RTS（请求发送：路由器老大，我接下来要占线 5 秒钟可以吗？）" ，路由器用大喇叭通知全屋所有人 "CTS（允许发送：A 要说话了，客厅的 C 给我闭嘴憋着！）"，以此提前把撞车掐死在摇篮里！

4.5 📌 本关重点标记（帮你分配脑力）

【★核心必透】CSMA/CD 四大核心考点：

只用于半双工有线网络：现在的全双工交换机网络已经不撞车了，不用它；无线网用 CSMA/CA。
争用期（ 2 τ 2\tau 2τ）与最小帧长计算 ：为了确保在把帧发完之前能听到最远处的撞车回音，必须满足 最小帧长 = 速率 × 2 τ \text{最小帧长} = \text{速率} \times 2\tau 最小帧长=速率×2τ 。以太网规定的最小帧长是 64 字节（512 bit），凡是小于 64 字节的帧全是冲突碎片残骸。
退避算法摇骰子范围 ：第 k k k 次碰撞后，从 $0 , 2 k - 1$ $0, 2\^k - 1$ $0,2k-1$ 中随机挑一个数（ k k k 最大取到 10），满 16 次 直接丢弃报错。

【◎重点掌握】CSMA/CD 与 CSMA/CA 的区别：CD 是有线网"撞了再说（事后检测）"，CA 是无线 WiFi"提前预约防撞（事前避免，用 ACK 和 RTS/CTS 解决隐蔽站问题）"。

4.6 🤔 第 4 关随堂小挑战与作业复盘

【为什么网速越快，网线反而不能拉太长？】
看一眼我们的黄金公式：最小帧长 = 发送速率 × 2 τ \text{最小帧长} = \text{发送速率} \times 2\tau 最小帧长=发送速率×2τ。
如果最小帧长固定死是 64 字节 不准变，现在你把网卡的发送速率提高了 10 倍 （说话手速快了 10 倍，瞬间就能把 64 字节说完）。请问：为了保证说完之前还能听到最远处的撞车回音，允许的最大单程跑路时间 τ \tau τ（也就是网线的最大长度）必须怎么变？
【捉鬼题】 ：
假设 2 楼的收货员从网线上收到了一封只有 42 字节 的信。请问收货员需要用 CRC 去检查这封信对不对吗？他应该怎么处理这封 42 字节的信？为什么？
【摇骰子实战】 ：
电脑 A 和电脑 B 刚刚发生了 第 3 次碰撞（ k = 3 k=3 k=3） 。请问此时它们俩各自掏出来的骰子，上面写着从 0 到几的数字？

🔍 作业复盘与解析

第 1 题 ：根据公式最小帧长 = 速率 × 2 τ \text{最小帧长} = \text{速率} \times 2\tau 最小帧长=速率×2τ，当最小帧长（64 字节）锁死不变，而说话速率提高了 10 倍 时，允许的往返时间 2 τ 2\tau 2τ（以及网线的最大长度 ）就必须缩短为原来的十分之一 ！（比如原来能拉 2000 米的网线，网速提了 10 倍后，网线最多只能拉 200 米，否则最远处的撞车回音就听不到了。反之，如果网速不变而网线长度增加一倍， 2 τ 2\tau 2τ 翻倍，最小帧长也必须跟着翻倍！）。
第 2 题 ：收到只有 42 字节的信，连 64 字节的及格线都没到，说明这百分之百是半路撞车后紧急闭嘴留下的冲突碎片残骸 ，根本不用浪费力气算 CRC，直接当垃圾丢弃。
第 3 题 ：第 3 次碰撞（ k = 3 k=3 k=3），骰子的数字范围是 0 ∼ ( 2 3 − 1 ) 0 \sim (2^3 - 1) 0∼(23−1)，即 0 ~ 7（共 8 个数）。

第五节（第 5 关）：2 楼的聪明管家（MAC 地址、以太网帧与交换机自学习）

看到上一关第 1 题的结论，当时的网络工程师们彻底急眼了：

"网速每快 10 倍，网线就得剪短 10 倍！那以后网速到了千兆、万兆，网线岂不是只能拉几厘米长了？！这破'大黑屋抢话（集线器 + CSMA/CD）'的日子没法过了，必须把大黑屋砸了！"

是谁出手砸烂了大黑屋，彻底终结了"撞车时代"？

这就迎来了我们数据链路层的最后一关------从"无脑大喇叭"进化到"私人包厢管家"（交换机 Switch）！

5.1 第一幕：网卡娘胎里带出来的身份证 ------ MAC 地址

要想不靠大喇叭瞎喊、实现精准递信，首先我们得给屋里的每一台电脑发一张独一无二的身份证。

在 2 楼（数据链路层），这张身份证就叫 MAC 地址（也叫物理地址、硬件地址）。

它长什么样？（【◎重点掌握】）

全世界每生产一块网卡，出厂时厂家就会用激光在芯片里刻死一串 48 位（也就是 6 个字节） 的二进制数字。为了方便人类看，通常写成 12 个十六进制数，比如：00-1A-2B-3C-4D-5E。
它和我们常听说的 IP 地址有什么区别？
MAC 地址 就像你的身份证号：从出生刻死，你哪怕从北京搬家到上海，身份证号也跟一辈子不变（在当前这一小段局域网内部认人用）。
IP 地址 就像你的现居住地址（"北京市海淀区XX号"）：一旦你搬家去了上海，就得换成上海的居住地址（跨网段全国指路用）。
一个特殊的"全体起立"号码 ------ 广播 MAC 地址 ：

如果在 2 楼，有一封信真的是想发给屋里所有人 看的，收件人该写谁？工程师规定：只要把收件人的 48 位二进制全写成 1（也就是 FF-FF-FF-FF-FF-FF），就代表"屋里所有人全给我收下！"

🔗 顺手揭晓一个惊天伏笔：为什么以太网规定正文最少要塞够 46 字节？

现在有了收件人 MAC 和发件人 MAC，我们来看看 2 楼车队真正打包出来的 以太网帧（Frame） 长什么样（【★核心必透】必考加减法）：

text 复制代码

|<------------------------- 整个包裹最少必须满 64 字节 ------------------------->|
+--------------+--------------+--------+------------------------+--------------+
| 目的MAC地址   | 源MAC地址      | 类型   |   3楼扔下来的真正数据     | FCS防伪校验尾  |
|   (6 字节)   |   (6 字节)     | (2字节)|    (46 ~ 1500 字节)     |   (4 字节)    |
+--------------+--------------+--------+------------------------+--------------+
 \_______________ 帧首部 (14字节) _____/                          \_ 帧尾(4字节)_/

拿出手指头算一笔小学加减法：

包裹的外壳一共重多少？
前面有 6字节(目的MAC) + 6字节(源MAC) + 2字节(类型) = 14 字节的头 ；后面还有 4字节(CRC防伪尾)。外壳加起来一共是 14 + 4 = 18 字节 14 + 4 = 18\text{ 字节} 14+4=18 字节 ！（记住 18 这个黄金数字）。
上一关我们刚学过，为了防撞车漏听，整个包裹加起来最少必须满 64 字节 ！
既然外壳占掉了 18 字节，那么夹在中间的"真正数据"最少得塞多少字节？

64 − 18 = 46 字节！ 64 - 18 = \mathbf{46\text{ 字节}}！ 64−18=46 字节！

如果 3 楼扔下来的数据不到 46 字节（比如只有 10 字节），2 楼就必须在后面强行塞 36 字节的废话，凑够 46 字节 ！(至于最多能塞多少？规定最多塞 1500 字节 ，这个上限叫 MTU 最大传输单元，下一章网络层切包裹全靠它！)

5.2 第二幕：聪明管家登场 ------ 交换机（Switch）是怎么偷偷记笔记的？

好，现在我们把 1 楼那个文盲"集线器（Hub）"扔进垃圾桶，换上 2 楼的神器------交换机（Switch） ！

交换机住在 2 楼，它长了眼睛，认得信封上的 MAC 地址！而且它手里随时揣着一本【小本本（交换表 / MAC 地址表）】。

最神奇的地方来了：交换机刚从京东买回来插上电的时候，它的小本本是完全空白的 ！没有人告诉它哪个插口插着哪台电脑。

那它是怎么靠自己把小本本填满的呢？这就是必考大题------【★核心必透】交换机的自学习算法（Self-Learning）！

它的座右铭只有两句话：

"凡是进门的信，先看一眼【发件人是谁】，把发件人和进门插口记在小本本上！"（逆向学习源地址）

"再看一眼【收件人是谁】，小本本上查不到就朝所有门大喊一嗓子（广播/盲目转发）；查到了就直接精准塞进那个门（单播）！"

我们用两幅连环画，看一台刚拆封的交换机是怎么在 2 秒钟内变聪明的（假设 1号口插着电脑A，2号口插着电脑B，3号口插着电脑C）：

🎬 第一秒：电脑 A（从 1 号口）给电脑 B 发了一封信 `[发件人:A -> 收件人:B]`

text 复制代码

   [电脑 A]                   [电脑 B]                   [电脑 C]
     │1号口                     │2号口                      │3号口
     ▼                          │                          │
+-------------------------------------------------------------------+
| 【交换机】 收到信！                                                  |
|  动作1(偷记发件人)：信是从1号口进来的，发件人是A！赶紧记下：[A 在 1号口]    |
|  动作2(查找收件人)：收件人是B，翻小本本......空的！不知道B在几号口！           |
|  动作3(大喊一嗓子)：朝除1号口以外的所有口(2号、3号)全都发一份！            |
+-------------------------------------------------------------------+
                 【当前小本本】： | A ──> 1号口 |

结果：2号口的 B 收到了信；3号口的 C 也收到了，但 C 拆开一看收件人是 B，就顺手扔掉了。

🎬 第二秒：电脑 B（从 2 号口）给电脑 A 回了一封信 `[发件人:B -> 收件人:A]`

text 复制代码

   [电脑 A]                   [电脑 B]                   [电脑 C]
     ▲1号口                     │2号口                     │3号口
     │ (精准私聊！)              ▼                         │ (安静如鸡，根本没收到！)
+-------------------------------------------------------------------+
| 【交换机】 收到B的回信！                                              |
|  动作1(偷记发件人)：信是从2号口进来的，发件人是B！赶紧记下：[B 在 2号口]    |
|  动作2(查找收件人)：收件人是A，翻小本本......哈哈！刚才记过 A 在 1号口！       |
|  动作3(精准送达！)：直接把信悄悄塞进 1号口！绝对不打扰 3号口的 C！         |
+-------------------------------------------------------------------+
            【当前小本本】： | A ──> 1号口 | B ──> 2号口 |

你看明白了吗？！

仅仅经过这一来一回，交换机的小本本上就已经把 A 和 B 的位置摸得一清二楚了！以后 A 和 B 再聊一万句，3号口的可怜虫 C 连半点声音都听不到！

(注：为了防止有一天你把电脑 A 拔下来换到 3 号口，小本本上的每条记录都有个*"保质期（老化时间）"，如果好几分钟 A 都没说话，交换机就会把 A 的记录擦掉重学。)*

5.3 第三幕：交换机带来的降维打击 ------ 彻底消灭"吵架屋"！

现在，你把 1 楼的 集线器（Hub） 和 2 楼的 交换机（Switch） 放在一起比一比，就能明白为什么现在的网吧、宿舍、公司全都在用交换机了：

把大黑屋切成了独立私人包厢（隔离冲突域）：

以前用集线器（Hub），4 台电脑关在 1 个大吵架屋（1 个冲突域） 里；
现在换了交换机（Switch），交换机内部有精密的立交桥电路，A 给 B 发信的同时，C 可以同时给 D 发信，两边各走各的独立通道，绝对不会撞车！
【★核心必透】结论 ：交换机的每一个插口，都是一个自己独立的冲突域 ！如果你把 4 台电脑插在交换机的 4 个口上，就有 4 个独立的冲突域 （每间包厢里只有 1 台电脑自己跟交换机连着，开启全双工，连撞车的对象都没有了，所以现代全双工交换机网络里彻底不需要再用 CSMA/CD 协议了！）。

每个人独享整块大蛋糕（独享带宽）：

以前 100 兆的 Hub 插 4 台电脑，每人只能分到 100 ÷ 4 = 25 兆 100 \div 4 = 25\text{ 兆} 100÷4=25 兆；
现在 100 兆的交换机插 4 台电脑，每一台电脑都能结结实实独享 100 兆的网速！

🚨 唯一拦不住的东西 ------ 广播大喇叭（不隔离广播域） ：
虽然交换机能把普通悄悄话关在包厢里，但如果电脑 A 发了一封收件人写着 FF-FF-FF-FF-FF-FF（全体广播） 的信呢？
交换机一看收件人是"全体人员"，它作为 2 楼的管家，必须忠实地把这封广播信复制给屋里所有插口！

【★核心必透】必背金句：
1 楼集线器（Hub） ：既不隔离冲突域 ，也不隔离广播域（彻头彻尾的大黑屋）。
2 楼交换机（Switch） ：隔离冲突域 （每个口都是独立包厢），但不隔离广播域（全体广播还是会传遍全屋）！
(剧透一下：谁才能把讨厌的"全体广播"也死死拦住呢？答案是 3 楼的路由器 ！或者在交换机里用软件切出虚拟隔间，叫 【○有个概念即可】VLAN 虚拟局域网。)

5.4 🎬 第三章（数据链路层）网课辅助建议

到这里，计网里的第一座大山------《第三章：数据链路层》就已经全部攻克了！

完全不用看网课的地方：PPP 协议/HDLC 协议的生僻历史字段、网桥的生成树算法（STP）细节、各种局域网 IEEE 802.x 编号。
建议去看 5~10 分钟网课动画的地方：如果对第 3 关的"GBN 与 SR 滑动窗口动态滑动过程"想加深视觉印象，可以去王道网课拖进度条只看这 5 分钟的动画演示，其余时间直接省下来做几道选择题即可。

5.5 🤔 第三章终极通关 Boss 测试与答案解析

题目 1：【以太网帧解剖题】

3 楼（网络层）的快递部刚刚打包好了一个只有 20 字节 的小包裹（IP 数据报），扔给了 2 楼（数据链路层）的以太网车队。

请问：2 楼车队在给它套上 18 字节的外壳（14 字节头 + 4 字节尾） 之前，必须先在它屁股后面塞入多少字节的填充废话？最终发到 1 楼网线上的这整个以太网帧一共是多少字节？

【答案与解析】

答：必须先塞入 26 字节 的填充废话；最终整个以太网帧一共是 64 字节。
解析：以太网规定整个帧最小必须满 64 字节 。扣除 2 楼套上的 18 字节外壳（14 字节首部 + 4 字节 FCS 尾部） ，中间的数据部分最少必须达到 64 − 18 = 46 字节 64 - 18 = \mathbf{46\text{ 字节}} 64−18=46 字节。现在 3 楼只扔下来 20 字节，还差 46 − 20 = 26 字节 46 - 20 = \mathbf{26\text{ 字节}} 46−20=26 字节，所以必须填充 26 字节的 0，凑满 46 + 18 = 64 字节 46 + 18 = \mathbf{64\text{ 字节}} 46+18=64 字节后再发往 1 楼网线。

题目 2：【交换机小本本推演题】

一台刚通电、小本本全空的交换机，1 号口连着 A，2 号口连着 B，3 号口连着 C。

第 1 步：A 给 C 发了一封信。请问此时 B 会不会收到这封信？为什么？

第 2 步 ：紧接着，B 给 A 发了一封信（注意看清楚：是 B 发给 A！）。请问这一次，无关人员 C 还会收到这封信吗？为什么？

【答案与解析】

第 1 步解答 ：B 会收到这封信！
原因：交换机刚通电小本本是空的。当 A 从 1 号口发信给 C 时，交换机先执行"逆向学习"记下 [A -> 1号口]；接着查收件人 C，发现小本本上还没有 C 的记录，于是只能向除 1 号口外的所有端口（2 号口 B 和 3 号口 C）进行盲目转发（广播），所以 B 也会收到（B 拆开看不是找自己的就丢弃）。
第 2 步解答 ：无关人员 C 不会收到这封信！
原因：当 B 从 2 号口发信给 A 时，交换机先记下 [B -> 2号口]；接着查收件人 A，翻看小本本发现第 1 步已经记下了 [A -> 1号口] ！于是交换机直接把信精准塞进 1 号口（单播转发），根本不会往 3 号口发，所以 C 完全收不到。

题目 3：【数房间终极必考题】

现在有一台 交换机（Switch） ，它的 4 个插口上分别插了 4 台电脑。请问这 4 台电脑一共形成了几个 冲突域 ？几个 广播域？

【答案与解析】

答：形成了 4 个冲突域 ，1 个广播域！
解析：2 楼交换机（Switch）的核心特性是"隔离冲突域，但不隔离广播域"。交换机的每一个端口都是一个独立的私人包厢（冲突域），4 个端口插 4 台电脑就有 4 个冲突域 ；但一旦有人发送全 F 的广播帧，交换机依然会向所有端口转发，所以全屋依然处在 1 个广播域 中。

第六节：📝 复习心得与大白话核心笔记（考前速查）

组帧与透明传输：插红旗与防误切

2 楼拿到 1 楼的 0/1 豆子流，第一件事是在前后插上头旗和尾旗打包成帧（Frame）。
万一正文里长了跟真旗帜一模一样的假旗帜怎么办？这就需要透明传输：
字节填充（字符填充） ：跟写 C++ 字符串加转义符 \ 一模一样，正文里只要出现 FLAG 或 ESC，前面统统塞一个 ESC 免死金牌。
零比特填充（必考手工题） ：真旗帜是 01111110（6 个 1）。发货时只要数满 连续 5 个 1 ，不管后面是啥，无脑塞一个 0；收货时每数满 连续 5 个 1 ，就把屁股后面紧跟的那个 0 抠掉。千万注意连续七八个 1 的时候别漏塞！

差错检测：奇偶校验 vs CRC 循环冗余校验

2 楼以太网只检错、不纠错！ 查出被雷劈坏了直接扔垃圾桶，重发的活儿甩锅给 4 楼 TCP（只有无线 WiFi 因为干扰太大才在 2 楼自己重传）。
奇偶校验 ：数 1 的个数凑单数或双数。致命弱点是只能查出奇数个错误，同时坏偶数个豆子直接瞎掉。
CRC 计算三步走 ：① 看除数有 k k k 位（或者多项式最高次方是 r = k − 1 r=k-1 r=k−1），就在原始数据后面补 k − 1 k-1 k−1 个 0；② 做模 2 除法（异或消消乐：相同为 0，不同为 1，打头是 1 摆除数，打头是 0 往下滑 ）；③ 把算出来的余数（FCS ）填进刚才补的 0 里发走。接收方除以同一个除数，余数为 0 就是好帧。

滑动窗口三兄弟：停止-等待、GBN、SR

停止-等待 ：扔一块等一声。为了防"数据丢"定了超时闹钟 ；为了防"ACK 丢了导致重复砌墙"，给砖头贴上 0 和 1 交替编号 （收到重复帧直接扔掉，但必须重喊一次 ACK）。
GBN（强迫症哥哥，接收窗口 = 1 =1 =1） ：按序接收。一旦中间 2号 掉了，后面飞过来的 3号、4号 全部一脚踢进河里扔掉，发送方被迫把 2、3、4 全重扔一遍。优点是支持累积确认（喊一声 ACK 3 就代表 0、1、2、3 全收到了）。
SR（收纳狂弟弟，接收窗口 > 1 >1 >1） ：有储物架。2号 掉了，先把 3号、4号 存起来，发送方只单独补扔 2号 即可。
窗口上限一条公式通杀 ：发送窗口 + 接收窗口 ≤ 2 n \text{发送窗口} + \text{接收窗口} \le 2^n 发送窗口+接收窗口≤2n。所以 GBN 最大发送窗口是 2 n − 1 2^n - 1 2n−1 ，SR 最大窗口是 2 n − 1 2^{n-1} 2n−1。

CSMA/CD 与 CSMA/CA：有线撞了再说，无线提前预约

CSMA/CD（有线半双工总线/集线器专用）：16 字口诀"先听后发，边发边听，碰撞停发，随机重发"。
争用期 2 τ 2\tau 2τ 与最小帧长 64B ：因为最远处的撞车残骸跑回来最多要花一个来回（ 2 τ 2\tau 2τ），为了防止说完摘耳机漏听撞车，所有人说话必须拉长音说满 2 τ 2\tau 2τ，即 最小帧长 = 速率 × 2 τ = 64 字节（512 bit） \text{最小帧长} = \text{速率} \times 2\tau = 64\text{ 字节（512 bit）} 最小帧长=速率×2τ=64 字节（512 bit）。凡是小于 64 字节的帧全是冲突碎片残骸，直接扔！
摇骰子退避 ：第 k k k 次碰撞在 $0 , 2 k - 1$ $0, 2\^k - 1$ $0,2k-1$ 里摇随机数（ k k k 封顶为 10，满 16 次直接放弃报错）。
CSMA/CA（无线 WiFi 专用） ：无线信号发出去时身边太响听不见回音，加上隔墙有隐蔽站问题 ，没法边发边听，只能靠 ACK 确认 和 RTS/CTS 举手预约 提前避免碰撞。

MAC 地址、以太网帧与交换机（Switch）

以太网帧加减法（必背数字 18 和 46） ：外壳共 18 字节 （6B 目的 MAC + 6B 源 MAC + 2B 类型 + 4B 尾部 FCS）。因为总帧长最少 64 字节 ，所以中间 3 楼传下来的数据最少必须满 64 − 18 = 46 字节 64 - 18 = 46\text{ 字节} 64−18=46 字节（不够 46B 就塞 0 填充，最多不超过 MTU = 1500B）。
交换机自学习 ：进门先看源 MAC 记入小本本（逆向学习）；出门再查目的 MAC，小本本上查不到就除进门端口外全屋广播，查到了就精准单播。
数房间铁律 ：1 楼 Hub 既不隔冲突域也不隔广播域；2 楼交换机隔离冲突域（一个口一个冲突域，全双工独享带宽，彻底淘汰 CSMA/CD），但不隔离广播域；3 楼路由器（或 VLAN）才隔离广播域！

计算机网络第三章：数据链路层