区块链原理 / 系统课时

用 Python 搭建节点消息模拟器

用 Python 搭建节点消息模拟器

当两个节点几乎同时提出区块时,不同节点可能因为消息延迟而看到不同的链上信息。本课使用 Python 标准库实现一个可运行的离散事件模拟器,通过调整节点数量、消息延迟和发送顺序,观察区块消息如何传播、节点视图何时出现差异,以及这些差异何时消失。

学习目标

  • 使用节点状态、消息事件和优先队列实现可复现的消息模拟。
  • 调整节点数量、传播延迟与发送顺序,观察不同时间点的节点视图。
  • 区分消息传播完成、节点视图一致和共识最终性三个不同概念。

定义节点状态与消息传递模型

先建立一个最小场景:所有节点都知道创世区块 G,节点 N0 提出区块 A,最后一个节点提出区块 B。A 和 B 都以 G 为父区块,因此代表同一高度上的两个竞争候选区块。

模拟器不立即决定哪一个区块胜出,而是为每个节点维护独立的已知区块集合。收到消息时,节点只将相应区块加入集合,不自动选择主链。

模型包含三个核心部分:

  1. 节点状态:每个节点拥有独立的 set,初始值为 {"G"},接收 A 或 B 后更新自己的集合。
  2. 消息事件:记录计划交付时刻、发送序号、发送节点、接收节点和区块标识。
  3. 事件队列:使用 heapq 按交付时刻从小到大处理消息,同一时刻按发送序号决定处理顺序。

例如,三个节点在初始广播完成、但消息尚未交付时的视图如下。

节点 初始已知区块 原因
N0 G、A N0 本地产生 A
N1 G 尚未收到其他节点的消息
N2 G、B N2 本地产生 B

这里的视图表示节点已经获得哪些区块的信息,不代表节点已经验证全部区块,也不代表其认可某条分支为最终链。

离散事件队列与三个节点的消息传播和视图变化

使用优先队列实现离散事件调度

真实网络依靠时钟和异步通信传递消息。为了让实验结果可复现,这里不使用 sleep() 或真实网络连接,而是把时间表示为整数 Tick。例如消息在 Tick 0 发出、传播延迟为 2 Tick,就在 Tick 2 交付。

使用 Python 3.10 或更新版本,新建 simulator.py,输入以下完整代码。程序仅依赖标准库,不需要安装第三方包。

python
import argparse
import heapq


def snapshot(views):
    # 固定区块显示顺序,便于比较不同节点的本地视图
    return " ".join(
        f"N{i}=[{','.join(b for b in ('G', 'A', 'B') if b in known)}]"
        for i, known in enumerate(views)
    )


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--nodes", type=int, default=3)
    parser.add_argument("--delay", type=int, default=2)
    parser.add_argument("--order", choices=("A,B", "B,A"), default="A,B")
    parser.add_argument("--until", type=int, default=3)
    args = parser.parse_args()

    if args.nodes < 2 or args.delay < 1 or args.until < 0:
        parser.error("nodes>=2, delay>=1, until>=0 are required")

    views = [{"G"} for _ in range(args.nodes)]
    producers = {"A": 0, "B": args.nodes - 1}
    queue = []
    seq = 0

    for block in args.order.split(","):
        sender = producers[block]
        views[sender].add(block)

        for receiver in range(args.nodes):
            if receiver == sender:
                continue

            # 奇数编号节点额外延迟1 Tick,模拟不同网络链路
            tick = args.delay + (receiver % 2)
            heapq.heappush(
                queue, (tick, seq, sender, receiver, block)
            )
            seq += 1

    print(f"t=0 {snapshot(views)}")

    while queue and queue[0][0] <= args.until:
        now = queue[0][0]

        # 同一时刻的消息全部交付后,再打印一次完整视图
        while queue and queue[0][0] == now:
            _, _, sender, receiver, block = heapq.heappop(queue)
            views[receiver].add(block)
            print(f"t={now} N{sender}->N{receiver}: {block}")

        print(f"t={now} {snapshot(views)}")

    print(f"remaining={len(queue)}")


if __name__ == "__main__":
    main()

其中,queue 中的每条事件采用 (tick, seq, sender, receiver, block) 结构。tick 决定什么时候交付,seq 是递增序号,用于保证同一交付时刻的事件处理顺序确定。

代码中人为规定偶数编号接收节点使用基础延迟,奇数编号接收节点额外增加 1 Tick。这只是可复现实验使用的网络模型,不代表真实区块链网络中的固定传播规律。

--until 指定观察截止时间。超过截止时间的消息仍保留在队列中,remaining 表示尚未交付的消息数量。

在保存脚本的目录中执行:

bash
python simulator.py --nodes 3 --delay 2 --order A,B --until 3

预期输出:

text
t=0 N0=[G,A] N1=[G] N2=[G,B]
t=2 N0->N2: A
t=2 N2->N0: B
t=2 N0=[G,A,B] N1=[G] N2=[G,A,B]
t=3 N0->N1: A
t=3 N2->N1: B
t=3 N0=[G,A,B] N1=[G,A,B] N2=[G,A,B]
remaining=0

输出揭示了两个关键时刻。Tick 2 时,N0 与 N2 已经分别收到对方提出的区块,知道 A、B 两条候选分支;N1 仍然只知道 G。Tick 3 时,N1 收到两个候选区块,三个节点的已知区块集合才变得相同。

这里不存在真正的线程并发。模拟器按照事件队列顺序推进逻辑时间,因此在相同参数下重复运行,消息交付次序和输出始终相同。

调整参数观察传播顺序与节点视图

模拟器提供四个可配置参数,分别控制网络规模、基础延迟、广播顺序和观察窗口。

参数 默认值 控制内容
--nodes 3 节点总数,最少为 2
--delay 2 基础传播延迟,单位为 Tick,最少为 1
--order A,B 两个候选区块的广播入队顺序
--until 3 最后处理的逻辑时刻,最少为 0

可以逐次只修改一个参数,记录节点视图变化,避免同时改变多个条件而无法解释结果。

缩短观察窗口

将 --until 改为 2,保持其余参数不变。程序只交付 Tick 2 的两条消息,最终 N1 仍然只有 G,remaining=2。

这表示观察窗口结束时还有两条消息尚未送达,不表示消息已经丢失,也不表示 N1 永远无法同步。

增加消息延迟

将 --delay 改为 4,同时保持 --until 3。全部四条消息的交付时刻都晚于观察窗口,因此只有初始节点视图,最后显示 remaining=4。

延迟增大后,节点之间保持不同视图的时间也会延长。不过,本模拟器并不包含超时重传、消息丢弃或节点离线逻辑,不能用它直接估算真实网络中的分叉概率。

反转广播顺序

将 --order 改为 B,A。由于两个区块的消息可能在同一 Tick 到达,发送序号会影响同一时刻事件的处理顺序。以三个节点、延迟 2 Tick 为例,Tick 2 将先记录 B 送达 N0,再记录 A 送达 N2。

但在当前只维护已知区块集合的实现中,先收到 A 还是先收到 B,不影响同一时刻全部消息处理完成后的集合。若未来加入先到先选、链权重或投票状态,不同顺序才可能进一步影响节点决策。

验收模拟结果并识别模型边界

对三个节点、基础延迟 2 Tick、广播顺序 A,B 的默认场景,可以使用以下检查表验收实现。

检查点 应满足的结果
Tick 0 N0 有 A,N2 有 B,N1 尚未看到 A/B
Tick 2 N0、N2 均知道 A/B,N1 仍只知道 G
Tick 3 三个节点均知道 G、A、B
队列余量 截止 Tick 3 为 0
重复运行 相同参数产生完全相同的输出

如果 Tick 2 时 N1 已经获得区块,优先检查是否遗漏了 receiver % 2 的额外延迟;如果同一时刻消息顺序不稳定,则检查是否将 seq 放在优先队列排序元组的第二个位置。

还需要注意,当前模型假设所有节点诚实、消息不会丢失、节点始终在线,且候选区块只由两个指定节点产生;消息由发送者直接广播给其他所有节点,不会经过中继转发。节点数量增加时,广播事件总数为 2 × (nodes - 1),不等价于完整区块链网络的通信负载。

模拟器的价值是把传播延迟造成的局部视图差异独立呈现出来。后续若要研究链分叉选择,可以在每个节点的状态中增加当前链头、区块父子关系与区块权重;若要研究交易最终性,则还必须进一步加入对应共识协议的确认或投票规则。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用 Python 搭建节点消息模拟器

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通