在上一篇文章中,我们看到 UDP 只用校验和检测损坏,并不解决丢失和乱序的问题。
那么文件传输或支付请求这类一个片段都不能丢的数据,要如何获得可靠性呢?
本文将逐步介绍,在可能丢失或损坏数据的底层之上构建
可靠数据传输
(reliable data transfer, rdt)的原理。
TCP 在实际中实现了这些原理,因此把这里构建的结构与 TCP 对照阅读,会更容易理解。
可靠传输的前提是,下层信道可能丢失或损坏数据。
我们从最简单的情况开始,每当增加一种信道问题,就改进一次协议。
如果信道既不丢失数据也不改变数据,发送方只需要把数据发出去。
接收方只需把收到的数据原样交给上层。
如果数据可能因比特错误而损坏,就必须先用校验和检测出损坏。
接收方收到未损坏的数据时发送
ACK
(肯定应答),收到损坏的数据时发送
NAK
(否定应答)。
发送方收到 NAK 后,重新发送相同的数据。
问题在于,ACK 或 NAK 本身也可能损坏。
如果 ACK 损坏,发送方无法判断发生了什么,该怎么办呢?
发送方在每个分组上交替使用序号
0 和
1。
接收方如果再次收到已接收过的序号,就判定为重复,丢弃该分组,只重新发送 ACK。
这样,因为 ACK 丢失而被重发的分组,就会被当作重复分组过滤掉。
如果 ACK 中携带最后一个正确接收分组的序号,就不再需要 NAK。
收到损坏的分组时,接收方重新发送前一个序号的 ACK,发送方看到这个 ACK 后便重发相同的分组。
如果分组完全消失,接收方不会发出任何东西,发送方就会一直等下去。
因此发送方在发送分组时启动一个
定时器
,如果在规定时间内没有收到 ACK,就重新发送。
如果定时器设置得太短,仍在传输途中的分组也会被重发,但由于有序号,接收方可以过滤掉这些重复分组。
rdt 3.0 是正确的,但发送方要等每个 ACK 返回后才发送下一个分组。
这种方式称为
stop-and-wait
(停等)。
例如,假设 1 Gbps 链路上发送 1,000 字节的分组,往返时间(RTT)为 30 ms。
把一个分组送入链路的时间
L/R 为 8,000 比特 ÷ 1 Gbps = 8 µs。
发送方的利用率为:
U = (L/R) / (RTT + L/R) = 0.008 ms / 30.008 ms ≈ 0.027%
即使链路是 1 Gbps,发送方实际使用的也只有 0.027%。
其余的时间都花在等待 ACK 上。
解决办法是
流水线
(pipelining):不等待每个 ACK,连续发送多个分组。
发送方最多可以有
N 个未确认的分组在途,这个范围称为
窗口
。
U = N·(L/R) / (RTT + L/R)
在相同条件下,取
N = 1000 时,利用率可提高到约 26.7%。
这是假设没有丢失的理论值。
使用流水线需要做出两个决定:如何处理丢失,以及接收方如何对待乱序到达的分组。
| 区分 | Go-Back-N | 选择重传(Selective Repeat) |
|---|
| 确认应答 | 累积 ACK(收到到 n 为止的所有分组) | 对每个分组单独 ACK |
|---|
| 定时器 | 对最早的未确认分组设一个 | 每个分组一个 |
|---|
| 重传范围 | 超时后整个窗口 | 只重传丢失的分组 |
|---|
| 接收方缓存 | 不需要,只按顺序接收 | 缓存乱序到达的分组 |
|---|
Go-Back-N
让接收方保持简单,但如果一个分组丢失,其后已正确收到的分组也会被丢弃,必须重发整个窗口。
选择重传
只重发丢失的分组,因而节省带宽,但接收方必须保存乱序到达的分组。

流水线方式的发送方在窗口内连续发送多个分组,接收方返回累积确认应答
👨💻
TCP 通过组合序号、累积 ACK 和定时器来实现这一原理。
因此,如果 TCP 连接中的重传看起来很频繁,可以检查是否确实发生了丢失,以及定时器设置得有多长。
下面的示例在 UDP 之上实现了停等方式。
接收端会故意丢弃 30% 的数据报,以模拟丢失。
rdt-stop-and-wait.mjsimport dgram from "node:dgram";
const PORT = 7171;
const messages = ["m0", "m1", "m2", "m3", "m4"];
const server = dgram.createSocket("udp4");
const received = [];
let expected = 0;
server.on("message", (buf, rinfo) => {
if (Math.random() < 0.3) {
console.log(` [net] drop seq=${buf[0]}`);
return;
}
const seq = buf[0];
if (seq === expected) {
received.push(buf.subarray(1).toString());
expected = 1 - expected;
}
server.send(Buffer.from([seq]), rinfo.port, rinfo.address);
});
const client = dgram.createSocket("udp4");
let seq = 0;
let i = 0;
let timer;
function sendCurrent() {
const payload = Buffer.concat([Buffer.from([seq]), Buffer.from(messages[i])]);
client.send(payload, PORT, "127.0.0.1");
timer = setTimeout(() => {
console.log(` timeout, retransmit seq=${seq}`);
sendCurrent();
}, 100);
}
client.on("message", (ack) => {
if (ack[0] !== seq) return;
clearTimeout(timer);
console.log(`ack seq=${seq} for ${messages[i]}`);
i++;
seq = 1 - seq;
if (i < messages.length) {
sendCurrent();
} else {
console.log("received:", received);
client.close();
server.close();
}
});
server.bind(PORT, () => sendCurrent());
每次运行丢失的位置都不同,因此重传次数也会随运行而变化。
不过,最后一行的
received 中始终按顺序包含
m0 到
m4。
这表明仅凭序号、ACK 和定时器,就能在容忍丢失的同时保持顺序。
需要注意的是,该示例只模拟了数据丢失,并未处理 ACK 丢失。
可靠数据传输由三种工具构成:
用序号区分重复与顺序,用确认应答告知接收情况,用定时器从丢失中恢复。
如果保持停等方式,只能使用链路容量的极小一部分,因此必须通过流水线在窗口中同时发送多个分组。
Go-Back-N 实现简单,选择重传则节省带宽。选择哪一种取决于丢失率和接收方的缓存能力。