别再傻等ACK了！用Python模拟对比停等、GBN和连续ARQ协议，看看谁才是网络传输的‘卷王’

别再傻等ACK了！用Python模拟对比停等、GBN和连续ARQ协议，看看谁才是网络传输的‘卷王’

网络传输协议就像快递员送包裹，有的快递员送一个包裹就要等客户签收确认才送下一个（停等协议），有的快递员一口气送好几个包裹但发现丢件就全部重送（GBN协议），还有的快递员只重送丢失的包裹（连续ARQ）。今天我们就用Python来模拟这三种"快递员"的工作效率，看看谁才是真正的"卷王"。

1. 准备工作：搭建Python模拟环境

在开始模拟之前，我们需要准备好Python环境。推荐使用Python 3.8+版本，并安装以下必要的库：

pip install numpy matplotlib tqdm

这三个库将分别用于数值计算、绘制图表和显示进度条。接下来，我们定义一个基础的网络环境模拟类：

class NetworkSimulator: def __init__(self, rtt=100, loss_rate=0.1): self.rtt = rtt # 往返时延(ms) self.loss_rate = loss_rate # 丢包率 self.current_time = 0 self.packets = [] def send_packet(self, seq_num): if random.random() > self.loss_rate: # 模拟传播延迟 arrival_time = self.current_time + self.rtt / 2 ack_time = arrival_time + self.rtt / 2 self.packets.append((seq_num, arrival_time, ack_time)) return True return False

这个基础类模拟了网络的两个关键参数：往返时延(RTT)和丢包率。send_packet方法模拟发送一个数据包的过程，有一定概率会丢包。

2. 停等协议：最保守的"快递员"

停等协议就像一位非常谨慎的快递员，每次只送一个包裹，必须等到客户签收确认后才会送下一个。让我们用Python实现这个逻辑：

def stop_and_wait(simulator, num_packets=100): delivered = [] seq_num = 0 while seq_num < num_packets: success = simulator.send_packet(seq_num) if success: # 等待ACK simulator.current_time += simulator.rtt delivered.append(seq_num) seq_num += 1 else: # 超时重传 simulator.current_time += simulator.rtt return delivered

我们可以通过改变RTT和丢包率来测试停等协议的性能：

从测试结果可以看出停等协议的主要问题：

• 信道利用率极低：大部分时间都在等待ACK
• 对延迟敏感：RTT越大，性能下降越明显
• 抗丢包能力弱：每次丢包都要等待超时

提示：在实际编码中，可以添加超时检测机制，而不是固定等待RTT时间，这样能稍微提高一些效率。

3. GBN协议：全有或全无的"快递员"

GBN(Go-Back-N)协议像是一位比较豪爽的快递员，他会一次性送多个包裹(窗口大小N)，但如果发现某个包裹丢失，他会把从丢失包裹开始的所有包裹都重新送一遍。

def gbn(simulator, num_packets=100, window_size=5): delivered = [] base = 0 next_seq = 0 while base < num_packets: # 发送窗口内的包 while next_seq < base + window_size and next_seq < num_packets: simulator.send_packet(next_seq) next_seq += 1 # 模拟接收ACK if random.random() > simulator.loss_rate: base += 1 delivered.append(base - 1) simulator.current_time += simulator.rtt / window_size else: # 发生丢包，回退N步 next_seq = base simulator.current_time += simulator.rtt return delivered

让我们比较不同窗口大小对GBN协议性能的影响：

# 测试不同窗口大小 window_sizes = [1, 3, 5, 7, 10] results = [] for ws in window_sizes: sim = NetworkSimulator(rtt=100, loss_rate=0.1) gbn(sim, num_packets=100, window_size=ws) efficiency = 100 / (sim.current_time / 100) # 简化的效率计算 results.append((ws, sim.current_time, efficiency))

绘制结果对比图：

import matplotlib.pyplot as plt plt.figure(figsize=(10, 5)) plt.plot([r[0] for r in results], [r[2] for r in results], 'bo-') plt.xlabel('Window Size') plt.ylabel('Channel Efficiency (%)') plt.title('GBN Protocol Performance vs Window Size') plt.grid(True) plt.show()

GBN协议的关键特点：

• 窗口大小是性能关键：窗口太小效率低，太大则重传开销大
• 适合低丢包环境：高丢包率会导致大量不必要重传
• 实现相对简单：接收方只需维护下一个期望的序列号

4. 连续ARQ：精准派送的"快递员"

连续ARQ(如选择重传协议)则是一位聪明的快递员，他只重传真正丢失的包裹，而不是全部重送。这需要更复杂的逻辑但效率更高。

def selective_repeat(simulator, num_packets=100, window_size=5): delivered = [False] * num_packets acked = [False] * num_packets base = 0 next_seq = 0 while base < num_packets: # 发送窗口内未确认的包 for seq in range(base, min(base + window_size, num_packets)): if not acked[seq]: simulator.send_packet(seq) # 模拟接收ACK for seq in range(base, min(base + window_size, num_packets)): if not acked[seq] and random.random() > simulator.loss_rate: acked[seq] = True delivered[seq] = True simulator.current_time += simulator.rtt / window_size # 移动窗口 while base < num_packets and acked[base]: base += 1 next_seq = base return [i for i, val in enumerate(delivered) if val]

让我们对比三种协议在不同网络条件下的表现：

从对比可以看出：

1. 停等协议简单但效率最低，只适合极低延迟网络
2. GBN协议在中等网络条件下表现尚可，但高丢包时性能下降快
3. 选择重传在各种条件下都表现最佳，但实现复杂度最高

5. 高级话题：动态调整窗口大小

在实际网络中，固定的窗口大小往往不是最优选择。TCP协议就实现了动态调整窗口大小的算法。我们可以模拟一个简单的自适应算法：

def adaptive_window(simulator, num_packets=100): delivered = [False] * num_packets window_size = 1 max_window = 10 base = 0 while base < num_packets: # 发送窗口内的包 for seq in range(base, min(base + window_size, num_packets)): simulator.send_packet(seq) # 模拟接收ACK ack_count = 0 for seq in range(base, min(base + window_size, num_packets)): if random.random() > simulator.loss_rate: delivered[seq] = True ack_count += 1 # 调整窗口大小 if ack_count == window_size: # 所有包都收到ACK window_size = min(window_size * 2, max_window) # 倍增 else: window_size = max(window_size // 2, 1) # 减半 # 移动窗口 base += ack_count simulator.current_time += simulator.rtt / window_size return [i for i, val in enumerate(delivered) if val]

这种自适应算法能够：

• 在网络状况好时快速增加窗口提高吞吐量
• 在出现丢包时减小窗口避免网络拥塞
• 动态平衡效率和可靠性

注意：实际TCP协议使用的拥塞控制算法(如Reno、Cubic等)要复杂得多，会考虑往返时间、ACK到达模式等多种因素。