SimPy进程顺序执行指南：确保任务按序完成

class Alg1(Node):
    def __init__(self, *args):
        Node.__init__(self, *args)
        # ... 其他初始化代码 ...
        self.procedure_1_proc = self.env.process(self.procedure_1()) # 误区所在
        self.procedure_2_proc = self.env.process(self.procedure_2()) # 误区所在

def procedure_2(self):
    yield self.env.timeout(some_sufficient_time) # 尝试等待 procedure_1 完成
    # ... procedure_2 的操作 ...

import simpy

# 假设 Node 是一个 SimPy 相关的基类，这里简化为普通类
class Node:
    def __init__(self, env, node_id):
        self.env = env
        self.node_id = node_id

class Alg1(Node):
    def __init__(self, env, node_id):
        super().__init__(env, node_id)
        # 移除在 __init__ 中创建 procedure_1 和 procedure_2 进程的语句
        # self.procedure_1_proc = self.env.process(self.procedure_1())
        # self.procedure_2_proc = self.env.process(self.procedure_2())
        print(f"[{self.env.now}] Node {self.node_id}: Alg1 initialized.")

    def procedure_1(self):
        """
        此函数包含 procedure_1 的操作。
        它必须首先启动，并且在完成之前不应中断。
        """
        print(f"[{self.env.now}] Node {self.node_id}: Procedure 1 started.")
        yield self.env.timeout(2)  # 模拟 procedure_1 需要 2 个时间单位
        print(f"[{self.env.now}] Node {self.node_id}: Procedure 1 finished.")

    def procedure_2(self):
        """
        此函数包含 procedure_2 的操作。
        在 procedure_1 完成后，此函数将接管。
        """
        print(f"[{self.env.now}] Node {self.node_id}: Procedure 2 started.")
        yield self.env.timeout(3)  # 模拟 procedure_2 需要 3 个时间单位
        print(f"[{self.env.now}] Node {self.node_id}: Procedure 2 finished.")

    def run(self):
        """
        此方法负责按顺序执行 procedure_1 和 procedure_2。
        """
        print(f"[{self.env.now}] Node {self.node_id}: ------RUN1-------- (Starting procedure 1)")
        # 创建 procedure_1 进程并等待其完成
        procedure_1_proc_handle = self.env.process(self.procedure_1())
        yield procedure_1_proc_handle

        print(f"[{self.env.now}] Node {self.node_id}: ------RUN2-------- (Procedure 1 done, starting procedure 2)")
        # 只有当 procedure_1 完成后，才会创建并等待 procedure_2 进程
        procedure_2_proc_handle = self.env.process(self.procedure_2())
        yield procedure_2_proc_handle

        print(f"[{self.env.now}] Node {self.node_id}: Sequential run finished.")

# --- 仿真环境设置与运行 ---
def setup_simulation(env):
    # 创建一个 Alg1 实例，并启动其 run 方法作为 SimPy 进程
    node_a = Alg1(env, node_id=0)
    env.process(node_a.run())

    # 如果有多个节点或需要并行运行多个 Alg1 实例，可以这样添加：
    # node_b = Alg1(env, node_id=1)
    # env.process(node_b.run())

# 初始化 SimPy 环境
env = simpy.Environment()
setup_simulation(env)

# 运行仿真直到时间 10
env.run(until=10)

[0] Node 0: Alg1 initialized.
[0] Node 0: ------RUN1-------- (Starting procedure 1)
[0] Node 0: Procedure 1 started.
[2] Node 0: Procedure 1 finished.
[2] Node 0: ------RUN2-------- (Procedure 1 done, starting procedure 2)
[2] Node 0: Procedure 2 started.
[5] Node 0: Procedure 2 finished.
[5] Node 0: Sequential run finished.