🌐 从"事件"开始理解仿真
如果你第一次接触 SimPy，可能会有点困惑------这个框架里没有 sleep()，没有线程，甚至没有真实的时间流逝。它靠什么驱动？答案只有两个字：事件。
SimPy 的整个仿真世界，本质上是一条按时间排列的事件队列。进程等待事件、事件触发回调、回调推动下一个事件......周而复始，构成了你所模拟的那个"现实"。搞懂事件系统，就等于拿到了这台机器的说明书。
📌 事件的一生：三个阶段
每个事件从诞生到消亡，会经历三种状态。这不是什么复杂的概念，想象一下你在餐厅点了一道菜：
- 未触发（Pending） ：菜单已下，厨房还没开始做。
triggered = False - 已触发（Triggered） ：厨师已接单，菜马上要上桌。
triggered = True - 已处理（Processed） ：菜已上桌，食客开始动筷。
processed = True
| 状态 | triggered |
processed |
说明 |
|---|---|---|---|
| 未触发（Pending） | False |
False |
事件刚创建，尚未发生 |
| 已触发（Triggered） | True |
False |
已安排处理，回调即将被调用 |
| 已处理（Processed） | True |
True |
所有回调已执行完毕 |
状态是单向流转 的，没有回头路。事件通过 succeed()、fail() 或 trigger() 完成从"等待"到"触发"的跃迁，随后由环境（Environment）在合适的仿真时刻调用所有注册的回调函数。
🔑 两个优先级，一个占位符
模块里有三个全局常量，平时不显眼，关键时刻却很重要。
PENDING = object() 是事件值的占位符 。当你试图访问一个还没触发的事件的 .value，内部用的就是这个对象------别手动去比较它，交给框架处理就好。
优先级的设计更有意思。SimPy 用数字表示优先级，数字越小越优先：
URGENT = 0：紧急优先级，专门留给中断（Interrupt）和进程初始化。NORMAL = 1：普通优先级，日常事件的默认值。
这个设计意味着，当同一仿真时刻有多个事件排队，中断永远比普通超时先处理------这符合直觉，也是 SimPy 能正确模拟"紧急情况"的基础。
🧱 基类 Event：一切的起点
python
class simpy.events.Event(env: Environment)Event 是所有事件类型的祖先，可以直接使用，也可以派生出各种专用子类。理解它的属性和方法，后面的内容就会顺畅很多。
属性速览
env --- 事件绑定的仿真环境，创建时必须传入，之后不可更换。
callbacks --- 一个普通的 Python 列表，存放所有回调函数。事件被处理时，列表里的函数会依次以事件本身为参数被调用。你完全可以手动往里塞函数：
python
event.callbacks.append(my_callback_func)ok --- 成功触发（succeed()）时为 True，失败触发（fail()）时为 False。触发之前访问它？AttributeError 伺候。
defused --- 专门为失败事件准备的"灭火器"。事件通过 fail() 触发后，它的值是一个异常对象。如果没人处理，环境在执行 step() 时会把这个异常重新抛出 ，整个仿真可能因此崩溃。在回调里把 event.defused = True 设上，就是告诉环境："这个异常我已经处理好了，不用再抛。"
python
def my_callback(event):
if not event.ok:
print(f"捕获到错误: {event.value}")
event.defused = True # 异常已处理，环境请放行value --- 事件携带的返回值，触发后才可访问。在进程里 yield 一个事件，拿到的就是这个值：
python
result = yield some_event # result 即 some_event.value三个核心方法
succeed(value=None) --- 标记成功、设置值、安排处理，返回事件本身（支持链式调用）。对已触发的事件再调用，抛 RuntimeError。
fail(exception) --- 标记失败、以异常为值、安排处理。传入的必须是 Exception 实例，否则抛 TypeError。
trigger(event) --- 用另一个事件的状态和值来触发自己，天生适合做链式回调：
python
event_a.callbacks.append(event_b.trigger)
# event_a 完成时，自动以相同状态触发 event_b运算符魔法：& 和 |
Event 还重载了 & 和 | 运算符，两个事件一拼，就生成一个 Condition 事件：
python
yield event_a & event_b # 两者都完成才继续
yield event_a | event_b # 任一完成就继续这个语法糖用起来相当顺手，后面会专门展开。
⏱️ Timeout：最常用的那个
python
class simpy.events.Timeout(env, delay, value=None)如果说 Event 是基础设施，Timeout 就是你每天都在用的工具。它的逻辑极其简单：等一段时间，然后触发。
Timeout 有个与众不同的地方------创建即触发 ，不需要手动调用 succeed()。delay 指定延迟多少仿真时间，value 可以携带任意返回值。
实际开发中，几乎不会直接 new 一个 Timeout，而是用环境的便捷方法：
python
def process(env):
print(f"[{env.now}] 开始等待 5 个时间单位")
result = yield env.timeout(5, value="完成！")
print(f"[{env.now}] 等待结束，返回值: {result}")
env = simpy.Environment()
env.process(process(env))
env.run()
# [0] 开始等待 5 个时间单位
# [5] 等待结束，返回值: 完成！env.timeout() 是 Timeout(env, delay, value) 的封装，写起来更简洁，也是官方推荐的姿势。
⚙️ Process：进程本身也是事件
python
class simpy.events.Process(env, generator)这是 SimPy 设计里最精妙的一笔：进程不仅是执行单元，它本身也是一个事件 。当生成器函数跑完，这个 Process 事件就自动触发------这意味着你可以直接 yield 一个进程，等它结束：
python
def sub_process(env):
yield env.timeout(3)
return "子进程完成"
def main_process(env):
proc = env.process(sub_process(env))
result = yield proc # 安静等待子进程跑完
print(f"[{env.now}] 收到: {result}")除了等待，Process 还支持中断 。调用 proc.interrupt("原因") 会向目标进程注入一个 simpy.Interrupt 异常，进程需要用 try/except 接住：
python
def interruptible(env):
try:
yield env.timeout(10)
except simpy.Interrupt as interrupt:
print(f"被中断，原因: {interrupt.cause}")is_alive 属性则像一盏指示灯------True 表示进程还在跑，False 表示已经结束。
🔀 Condition：组合事件的艺术
python
class simpy.events.Condition(env, evaluate, events)Condition 让你把多个事件组合成一个新事件 ，等待满足特定条件时触发。日常使用基本不需要直接构造它，& 和 | 已经够用了。
两种内置组合方式：
| 写法 | 等价类 | 触发条件 |
|---|---|---|
e1 & e2 |
AllOf(env, [e1, e2]) |
所有事件都成功 |
| `e1 | e2` | AnyOf(env, [e1, e2]) |
Condition 的 .value 是一个字典，键是事件对象，值是各自的返回值。
python
# AllOf：等两个任务都做完
def process(env):
t1 = env.timeout(3, value="任务A")
t2 = env.timeout(5, value="任务B")
results = yield t1 & t2
print(f"[{env.now}] 全部完成: {list(results.values())}")
# [5] 全部完成: ['任务A', '任务B']
# AnyOf：谁先完成听谁的
def process(env):
t1 = env.timeout(3, value="快任务")
t2 = env.timeout(10, value="慢任务")
results = yield t1 | t2
print(f"[{env.now}] 率先完成: {list(results.values())}")
# [3] 率先完成: ['快任务']🗂️ 五种事件，一张全景图
| 事件类型 | 创建方式 | 触发方式 | 典型用途 |
|---|---|---|---|
Event |
env.event() |
手动 succeed() / fail() |
自定义同步信号 |
Timeout |
env.timeout(delay) |
自动（创建即触发） | 模拟时间延迟 |
Process |
env.process(gen()) |
生成器结束时自动触发 | 并发进程管理 |
Condition (AllOf) |
e1 & e2 |
所有子事件完成时 | 等待多个并发任务 |
Condition (AnyOf) |
`e1 | e2` | 任一子事件完成时 |
💡 综合实战：让它们协同工作
光看概念不够，下面这个例子把多种事件类型揉在一起，看看它们怎么配合：
python
import simpy
def worker(env, name, duration):
print(f"[{env.now}] {name} 开始工作")
yield env.timeout(duration)
print(f"[{env.now}] {name} 完成工作")
return f"{name}的结果"
def manager(env):
p1 = env.process(worker(env, "工人A", 3))
p2 = env.process(worker(env, "工人B", 5))
# 谁先完成，先汇报谁
first_done = yield p1 | p2
print(f"[{env.now}] 第一个完成的: {list(first_done.values())}")
# 再等所有人收工
all_done = yield p1 & p2
print(f"[{env.now}] 全部完成: {list(all_done.values())}")
env = simpy.Environment()
env.process(manager(env))
env.run()运行结果：
less
[0] 工人A 开始工作
[0] 工人B 开始工作
[3] 工人A 完成工作
[3] 第一个完成的: ['工人A的结果']
[5] 工人B 完成工作
[5] 全部完成: ['工人A的结果', '工人B的结果']逻辑清晰，时序准确------这就是 SimPy 事件系统的魅力所在。
🎯 几条真正有用的经验
用 SimPy 写多了，有几点体会值得提前知道：
事件状态不可逆。 一旦触发就无法撤销，设计仿真逻辑时要把这个约束放在心里。
失败事件要么处理，要么 defused。 让异常静悄悄地消失是危险的，但让仿真因为一个未处理的异常崩溃也很糟糕------明确决定怎么处理，别让它悬着。
Timeout 用 env.timeout()，别直接 new。 这不只是风格问题，便捷方法更安全，也更易读。
Process 是事件这件事，要真正内化。 一旦习惯了"进程可以被 yield"，很多并发逻辑写起来会自然很多。
& 和 | 的返回值是字典。 别忘了用 .values() 或按事件对象取值，直接打印 results 会让你一头雾水。
SimPy 的事件系统设计得相当克制------类型不多，但每一种都有清晰的职责边界。真正的复杂度，藏在你如何组合它们之中。