首页 理论 架构 工程 文档 白皮书 著作 研究 案例 下载 博客 关于 开始使用 →
首页 › 第七篇　Central 中央协调› 第28章　Coordinator

第28章　Coordinator

📅 2026年09月12日 👤 东塬一老翁 📂 第七篇　Central 中央协调

第七篇　Central 中央协调

第28章　Coordinator

本章大纲

  1. Coordinator
  2. 模块协调
  3. 状态协调
  4. 冲突协调
  5. 行为协调
  6. 生命周期协调
  7. Coordinator 与 Dispatcher
  8. 实际运行案例

28.1 Coordinator

Coordinator（协调器）是 SAI Framework 中负责协调多个模块、多个处理阶段以及多个运行状态，使它们按照既定依赖关系共同完成任务的组件。

上一章的 Dispatcher 解决：

“交给谁？”

本章的 Coordinator 解决：

“这些模块应该怎样一起运行？”

因此：

Central
   │
   ├── Dispatcher
   │      ↓
   │   决定交给谁
   │
   └── Coordinator
          ↓
       决定如何协同

28.1.1 Coordinator 的核心作用

SAI 中一个完整过程通常不是一个模块独立完成的。

例如：

Information
 ↓
Perception
 ↓
Cognition
 ↓
Memory
 ↓
Reasoning
 ↓
Decision
 ↓
Behavior
 ↓
Action

这些模块之间存在：

  • 顺序关系
  • 数据依赖
  • 状态依赖
  • 成功/失败关系
  • 冲突关系
  • 生命周期关系

Coordinator 就负责管理这些关系。

可以概括为：

Coordinator
=
Sequence
+
Dependency
+
State
+
Conflict
+
Lifecycle

28.2 模块协调

模块协调是 Coordinator 最基本的职责。

例如：

Perception
    ↓
Cognition
    ↓
Reasoning
    ↓
Decision
    ↓
Behavior

这里存在明显的依赖关系：

Cognition
依赖 Perception 结果

Reasoning
依赖 Cognition 结果

Decision
依赖 Reasoning 结果

Behavior
依赖 Decision 结果

Coordinator 需要保证：

前置模块完成以后，后置模块才能继续运行。

28.2.1 模块依赖

可以表示为：

Perception
    │
    ▼
Cognition
    │
    ▼
Reasoning
    │
    ▼
Decision
    │
    ▼
Behavior

例如：

Perception = completed
        ↓
允许 Cognition

Cognition = completed
        ↓
允许 Reasoning

Reasoning = completed
        ↓
允许 Decision

Decision = completed
        ↓
允许 Behavior

如果：

Reasoning = failed

那么：

Decision
   ↓
不能继续

28.2.2 模块协调不是模块调用

简单调用：

$engine->process($data);

只是一次调用。

Coordinator 则需要考虑：

是否可以调用？
什么时候调用？
调用前置条件是什么？
结果是否有效？
失败后怎么办？
下一模块是谁？

因此：

调用
≠
协调

28.2.3 模块协调流程

Input
 ↓
Coordinator
 ↓
检查依赖
 ↓
检查状态
 ↓
执行模块
 ↓
检查结果
 ↓
更新状态
 ↓
确定下一模块
 ↓
继续

这已经比单纯的 Dispatcher 更进一步。

28.3 状态协调

SAI 中每一个 Engine、Module、Individual、Device 都可能具有自己的状态。

例如：

PerceptionEngine = ready
CognitionEngine = waiting
ReasoningEngine = stopped
DecisionEngine = waiting
BehaviorEngine = waiting

Coordinator 必须根据这些状态决定下一步。

28.3.1 状态之间存在依赖

例如：

Perception
state = running

那么：

Cognition
state = waiting

是合理的。

但是：

Perception
state = failed

同时：

Cognition
state = running

就可能存在问题。

Coordinator 应该发现：

前置模块失败
       ↓
后置模块不应该继续

28.3.2 状态协调模型

Module State
     ↓
Coordinator
     ↓
检查前置条件
     │
     ├── 满足 → Continue
     │
     ├── 等待 → Waiting
     │
     ├── 冲突 → Conflict
     │
     └── 异常 → Error

28.3.3 状态同步

例如：

ReasoningEngine
    ↓
completed

Coordinator 可以更新整个任务：

Task
current_stage = decision

同时：

DecisionEngine
state = ready

于是形成：

Task State
    ↓
Module State
    ↓
Coordinator
    ↓
下一阶段

28.4 冲突协调

多个模块同时运行时可能产生冲突。

例如两个行为：

Behavior A
→ Fan ON

Behavior B
→ Fan OFF

如果同时执行：

Fan ON
Fan OFF

就产生行为冲突。

Coordinator 需要识别并处理这种冲突。

28.4.1 冲突的基本类型

可以包括：

Module Conflict
State Conflict
Decision Conflict
Behavior Conflict
Resource Conflict
Device Conflict

模块冲突

两个模块同时修改同一资源。

MemoryEngine
    ↓
修改 Memory

LearningEngine
    ↓
同时修改 Memory

需要协调访问顺序。

状态冲突

例如：

Fan.state = ON

但是另一个模块认为：

Fan.state = OFF

Coordinator 应该阻止直接覆盖，并交给状态处理机制确认实际状态。

决策冲突

例如：

Decision A
→ OpenWindow

Decision B
→ CloseWindow

两个决定互相冲突。

Coordinator 不能简单地两个都执行。

行为冲突

例如：

Action A
→ move_forward

Action B
→ move_backward

如果设备不允许同时执行：

forward
+
backward

Coordinator 必须协调。

28.4.2 冲突处理规则

可以采用：

发现冲突
 ↓
识别冲突对象
 ↓
比较优先级
 ↓
检查安全状态
 ↓
选择行为
 ↓
取消 / 延迟 / 替换其他行为

例如：

Normal Action
      +
Emergency Action
      ↓
Coordinator
      ↓
Emergency Priority Higher
      ↓
取消 Normal Action
      ↓
执行 Emergency Action

注意：

Coordinator 负责协调冲突处理过程，而不是代替 DecisionEngine 进行完整决策。

28.5 行为协调

Behavior 是最终走向 Action 的阶段。

一个 Individual 可能同时产生多个行为：

Behavior
├── Move
├── Stop
├── Speak
├── Open
└── Close

这些行为并不一定能够同时执行。

Coordinator 需要处理：

行为顺序
行为依赖
行为冲突
行为优先级
行为状态

28.5.1 行为顺序

例如机器人：

Stop
 ↓
Turn
 ↓
Move

不能简单变成：

Move
Turn
Stop

Coordinator 需要维护：

Action Sequence

28.5.2 行为依赖

例如：

Unlock Door
 ↓
Open Door
 ↓
Enter Room

存在：

Open Door
depends on
Unlock Door

因此：

Unlock = completed
        ↓
Open = allowed

28.5.3 行为资源冲突

例如：

Robot Arm

同时收到：

Action A → Move Arm Left
Action B → Move Arm Right

两个动作使用同一资源。

Coordinator 可以：

Action A
 ↓
执行
 ↓
完成
 ↓
Action B

而不是同时发送。

28.6 生命周期协调

Central、Engine、Individual 都有生命周期。

例如 Engine：

Created
 ↓
Initialized
 ↓
Ready
 ↓
Running
 ↓
Stopped

Individual：

Created
 ↓
Initialized
 ↓
Ready
 ↓
Running
 ↓
Learning
 ↓
Updating
 ↓
Running
 ↓
Stopped

Coordinator 需要保证各组件生命周期之间保持合理关系。

28.6.1 启动协调

例如：

Individual
   ↓
Central
   ↓
Dispatcher
   ↓
Coordinator
   ↓
Engines

不能在 Engine 尚未初始化时就让它处理任务。

正确：

Central Initialized
        ↓
Engines Initialized
        ↓
Engines Ready
        ↓
Coordinator Ready
        ↓
Central Ready
        ↓
Individual Running

28.6.2 停止协调

停止也需要顺序。

例如：

Individual
 ↓
停止接收新任务
 ↓
Coordinator
 ↓
停止行为
 ↓
停止 Engines
 ↓
停止 Central
 ↓
Stopped

这样可以避免：

Central 已停止
但是 BehaviorEngine 仍然执行 Action

28.6.3 异常生命周期

例如：

ReasoningEngine
      ↓
     Error

Coordinator 可以：

暂停当前任务
 ↓
阻止 Decision
 ↓
阻止 Behavior
 ↓
记录异常
 ↓
等待诊断

这为后面的 Self Maintenance 提供基础。

28.7 Coordinator 与 Dispatcher

这是本章最重要的区别之一。

Dispatcher

解决：

“交给谁？”

例如：

Scene
 ↓
Dispatcher
 ↓
PerceptionEngine

Coordinator

解决：

“怎么一起完成？”

例如：

Perception
 ↓
Cognition
 ↓
Reasoning
 ↓
Decision
 ↓
Behavior

Coordinator 管理整个过程。

28.7.1 两者结合

Central
   │
   ├── Dispatcher
   │      ↓
   │   找到目标模块
   │
   └── Coordinator
          ↓
       控制运行关系

完整流程：

Information
     ↓
   Central
     ↓
 Dispatcher
     ↓
PerceptionEngine
     ↓
Coordinator
     ↓
CognitionEngine
     ↓
Coordinator
     ↓
ReasoningEngine
     ↓
Coordinator
     ↓
DecisionEngine
     ↓
Coordinator
     ↓
BehaviorEngine

可以进一步概括：

Dispatcher = Target Selection
Coordinator = Process Coordination

28.7.2 Dispatcher + Coordinator + Central

最终形成：

                         Individual
                             │
                             ▼
                          Central
                         /       \
                        /         \
               Dispatcher       Coordinator
                   │                 │
              找目标模块         管理运行关系
                   │                 │
                   └────────┬────────┘
                            ↓
                         Engines
                            │
       ┌──────────┬─────────┼──────────┬─────────┐
       ▼          ▼         ▼          ▼         ▼
 Perception   Cognition  Reasoning  Decision  Behavior

三者关系：

组件 核心职责
Central 中央协调中心
Dispatcher 确定信息/任务发送给谁
Coordinator 协调模块之间如何运行

28.8 实际运行案例

下面用前面一直使用的房间温度控制案例，把三个组件真正连接起来。

假设：

Temperature = 32°C
Person = PRESENT
Fan = OFF

28.8.1 第一步：接收场景

TemperatureSensor
       ↓
SensorData
       ↓
Information
       ↓
InformationReceiver
       ↓
SceneCollector
       ↓
Scene

形成：

Scene
{
    temperature: 32,
    person: present,
    fan: off
}

28.8.2 第二步：Central 接收

Scene
 ↓
Central

Central 将 Scene 交给 Dispatcher。

28.8.3 第三步：Dispatcher 分发

Dispatcher 根据：

type = scene

找到：

perception

于是：

Dispatcher
     ↓
PerceptionEngine

28.8.4 第四步：Coordinator 协调

Perception 完成：

temperature
person
fan

Coordinator 检查：

Perception = completed

于是允许：

Cognition

28.8.5 第五步：认知

CognitionEngine

形成：

Person is present
Fan is off
Temperature is high

Coordinator 再检查：

Cognition = completed

允许进入：

Reasoning

28.8.6 第六步：推理

规则：

IF temperature > 30
AND person = present
AND fan = off

THEN need_cooling = true

得到：

Conclusion
need_cooling = true

28.8.7 第七步：决策

DecisionEngine：

Candidate A
→ Turn On Fan

Candidate B
→ Do Nothing

根据规则：

need_cooling = true

选择：

Turn On Fan

28.8.8 第八步：行为协调

BehaviorEngine：

Behavior
{
    action: "turn_on_fan"
}

Coordinator 检查：

Fan 当前 = OFF

没有冲突。

于是允许执行：

Action
 ↓
FanAdapter
 ↓
Fan

28.8.9 第九步：反馈

风扇启动：

Fan = ON

随后温度：

32°C → 29°C

Sensor 再次产生：

Feedback

流程：

Fan
 ↓
Sensor
 ↓
Information
 ↓
Feedback
 ↓
Dispatcher

Dispatcher 将 Feedback 分发到：

Memory
Experience
Learning
State

Coordinator 再协调这些模块的处理顺序。

28.8.10 如果发生冲突

假设同时存在：

Decision A
→ Fan ON

以及：

Decision B
→ Fan OFF

Coordinator 检查：

同一 Device
+
相反 Action

发现：

Behavior Conflict

于是：

Conflict
 ↓
Coordinator
 ↓
比较优先级
 ↓
检查当前 State
 ↓
确定允许的 Behavior
 ↓
Dispatcher
 ↓
目标 Adapter

如果无法安全确定，则：

Conflict
 ↓
暂停行为
 ↓
进入异常处理

而不是同时执行两个相反动作。

28.8.11 Coordinator 基础代码

下面建立一个基础 OOP 示例。

以下 PHP 代码是本章的设计示例，用于说明 SAI Framework 的 OOP 结构，未作为实际项目代码执行验证。

<?php

namespace SAI\Central;

class Coordinator
{
    protected $modules = array();

    protected $state = 'created';

    protected $current = null;


    public function register($name, $module)
    {
        $this->modules[$name] = $module;
    }


    public function get($name)
    {
        if (!isset($this->modules[$name])) {
            return null;
        }

        return $this->modules[$name];
    }


    public function setState($state)
    {
        $this->state = $state;
    }


    public function getState()
    {
        return $this->state;
    }


    public function setCurrent($name)
    {
        $this->current = $name;
    }


    public function getCurrent()
    {
        return $this->current;
    }
}

这个基础 Coordinator 主要保存：

Module
State
Current Stage

28.8.12 加入顺序协调

可以增加：

protected $sequence = array();

注册运行顺序：

public function setSequence(array $sequence)
{
    $this->sequence = $sequence;
}

例如：

$coordinator->setSequence(array(
    'perception',
    'cognition',
    'reasoning',
    'decision',
    'behavior'
));

于是：

perception
     ↓
cognition
     ↓
reasoning
     ↓
decision
     ↓
behavior

28.8.13 执行协调

可以进一步：

public function run($data)
{
    $result = $data;

    $this->state = 'running';

    foreach ($this->sequence as $name) {

        if (!isset($this->modules[$name])) {
            $this->state = 'error';
            return null;
        }

        $this->current = $name;

        $module = $this->modules[$name];

        $result = $module->process($result);

        if ($result === null) {
            $this->state = 'error';
            return null;
        }
    }

    $this->current = null;
    $this->state = 'completed';

    return $result;
}

这段代码表达的核心就是：

输入
 ↓
按顺序调用模块
 ↓
上一模块结果
 ↓
成为下一模块输入
 ↓
直到流程完成

本章小结

Coordinator 是 Central 内部非常重要的协调组件。

它不是：

Cognition
Reasoning
Decision
Behavior

也不是：

Dispatcher

它的核心职责是：

模块协调
状态协调
冲突协调
行为协调
生命周期协调

最终可以把第26～28章连接起来：

                    Individual
                         │
                         ▼
                      Central
                    /         \
                   /           \
          Dispatcher          Coordinator
              │                    │
          交给谁？              怎么协同？
              │                    │
              └──────────┬─────────┘
                         ▼
                       Engines
                         │
       ┌─────────┬───────┼───────┬─────────┐
       ▼         ▼       ▼       ▼         ▼
 Perception  Cognition Reasoning Decision Behavior
       │         │       │       │         │
       └─────────┴───────┴───────┴─────────┘
                         │
                         ▼
                       Action
                         │
                         ▼
                    External World

因此，第七篇 Central 的三个核心组件可以正式确定：

Central
│
├── Dispatcher
│     └── 负责“交给谁”
│
└── Coordinator
      └── 负责“如何协同”

最终形成：

Central 负责中央协调，Dispatcher 负责目标分发，Coordinator 负责过程协同。

这样，SAI Framework 就具备了从信息进入 → 模块分发 → 模块协同 → 行为执行的基础中央运行结构，为下一篇 Element / Object / Relation 建立内部数据和认知对象基础。

← 第27章　Dispatcher
第八篇　Element / Object / Relation →

Leave a Reply

Your email address will not be published. Required fields are marked *