3. Go 基础语法回顾：变量、常量、控制结构、函数、结构体与接口，为调度实现打底

在进入 DAG 调度核心实现之前，必须对 Go 语言的基础语法进行系统性回顾。调度引擎的每个组件——从任务节点的状态管理到拓扑排序的执行流——都直接映射到 Go 的变量作用域、控制结构、函数签名、结构体组合与接口抽象。本章聚焦于调度实现中最常使用的语法特性，避免泛泛罗列，而是以“调度视角”重新审视每个知识点。

3.1 变量与常量：调度状态与配置的基石

DAG 调度中，变量用于承载任务状态、执行计数、时间戳等动态数据；常量则用于定义任务阶段标签、默认超时、最大重试次数等不可变配置。

3.1.1 变量声明与作用域规则

调度器内部大量使用短变量声明（:=）简化局部状态管理，但必须警惕作用域陷阱：

// 典型错误：在 if 块内使用 := 导致外部变量未被赋值
var taskID string
if node, ok := dag.Nodes["task_a"]; ok {
    taskID, err := node.GetID() // 此处 taskID 是局部变量，外部 taskID 仍为空
    if err != nil {
        return err
    }
}
// 外部 taskID 未被修改

// 正确做法：使用 = 赋值
var taskID string
if node, ok := dag.Nodes["task_a"]; ok {
    var err error
    taskID, err = node.GetID()
    if err != nil {
        return err
    }
}
调度实践提示：在循环中更新 DAG 节点状态时，务必使用索引拷贝或指针接收，避免闭包捕获循环变量导致的竞态问题。

3.1.2 常量与 iota 枚举

调度阶段和任务状态使用常量枚举，保证类型安全和可读性：

type TaskPhase int

const (
    PhasePending TaskPhase = iota // 0
    PhaseReady                    // 1
    PhaseRunning                  // 2
    PhaseSucceeded                // 3
    PhaseFailed                   // 4
    PhaseSkipped                  // 5
)

const (
    DefaultTimeout    = 30 * time.Second
    MaxRetryCount     = 3
    DefaultQueueDepth = 1024
)
声明方式 作用域 调度场景示例
var x int 包级/函数级 全局 DAG 实例引用
x := value 函数内局部 遍历节点时的临时状态
const C = 10 包级 调度队列容量、超时阈值
iota 常量生成器 任务阶段枚举、优先级等级

3.2 控制结构：拓扑遍历与并发调度的骨架

DAG 调度核心逻辑依赖三种控制结构：for 循环驱动拓扑排序，select 管理多路并发信号，defer 保障资源释放与状态回滚。

3.2.1 for-range 与拓扑遍历

调度器使用 for-range 遍历 DAG 邻接表，计算入度并执行 Kahn 算法：

// 计算每个节点的入度
inDegree := make(map[string]int)
for nodeID := range dag.Nodes {
    inDegree[nodeID] = 0
}
for _, edges := range dag.Edges {
    for _, target := range edges {
        inDegree[target]++
    }
}

// 入度为 0 的节点入队
queue := make([]string, 0)
for nodeID, degree := range inDegree {
    if degree == 0 {
        queue = append(queue, nodeID)
    }
}

3.2.2 select 与多路调度信号

在并发调度引擎中，select 同时监听任务完成信号、超时信号和取消信号：

select {
case result := <-taskChan:
    // 任务完成，更新下游节点入度
    dag.updateDownstream(result.NodeID)
case <-time.After(DefaultTimeout):
    // 超时处理，标记任务为失败
    dag.markFailed(nodeID, "timeout")
case <-ctx.Done():
    // 上下文取消，优雅退出调度循环
    return ctx.Err()
}

3.2.3 defer 与状态回滚

调度器在修改节点状态时，使用 defer 确保异常情况下状态一致性：

func (d *DAG) executeNode(nodeID string) (err error) {
    d.mu.Lock()
    d.nodes[nodeID].Phase = PhaseRunning
    d.mu.Unlock()

    defer func() {
        if err != nil {
            d.mu.Lock()
            d.nodes[nodeID].Phase = PhaseFailed
            d.nodes[nodeID].Error = err.Error()
            d.mu.Unlock()
        }
    }()

    return d.runTask(nodeID)
}
常见陷阱：在 for 循环中直接使用 defer 会导致资源延迟释放。调度器中应使用匿名函数包裹或显式调用清理方法。

3.3 函数：一等公民与调度抽象

Go 函数作为一等公民，在调度器中承担三种角色：任务执行函数、回调钩子、依赖注入载体。

3.3.1 函数类型与回调

// 定义任务执行函数类型
type TaskFunc func(ctx context.Context, params map[string]interface{}) (interface{}, error)

// 定义生命周期钩子类型
type LifecycleHook func(nodeID string, phase TaskPhase)

// 调度器注册回调
func (d *DAG) OnNodePhaseChange(hook LifecycleHook) {
    d.hooks = append(d.hooks, hook)
}

3.3.2 闭包与上下文传递

调度器利用闭包捕获调度上下文，避免全局变量污染：

func (d *DAG) createTaskRunner(nodeID string) TaskFunc {
    node := d.nodes[nodeID] // 闭包捕获
    return func(ctx context.Context, params map[string]interface{}) (interface{}, error) {
        // 使用捕获的 node 信息执行任务
        log.Printf("Executing node: %s, dependencies: %v", nodeID, node.DependsOn)
        return node.Execute(ctx, params)
    }
}

3.3.3 可变参数与选项模式

调度器配置使用函数选项模式（Functional Options），保持 API 扩展性：

type SchedulerOption func(*Scheduler)

func WithMaxConcurrency(n int) SchedulerOption {
    return func(s *Scheduler) {
        s.maxConcurrency = n
    }
}

func WithRetryPolicy(retries int, backoff time.Duration) SchedulerOption {
    return func(s *Scheduler) {
        s.maxRetries = retries
        s.backoff = backoff
    }
}

func NewScheduler(opts ...SchedulerOption) *Scheduler {
    s := &Scheduler{
        maxConcurrency: 1,
        maxRetries:     0,
        backoff:        100 * time.Millisecond,
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

3.4 结构体与接口：DAG 节点的实体与契约

结构体承载 DAG 节点的数据状态，接口定义调度器与任务执行器之间的行为契约。两者结合实现松耦合、可测试的调度架构。

3.4.1 结构体定义与组合

// DAGNode 结构体：组合基础属性与运行时状态
type DAGNode struct {
    ID        string
    DependsOn []string
    Timeout   time.Duration
    Retries   int

    // 运行时状态（不参与序列化）
    Phase    TaskPhase
    Attempts int
    Result   interface{}
    Error    error

    // 内嵌执行器
    Executor TaskExecutor
}

// DAG 结构体：管理节点集合与边关系
type DAG struct {
    mu     sync.RWMutex
    Nodes  map[string]*DAGNode
    Edges  map[string][]string // 邻接表
    Hooks  []LifecycleHook
}

3.4.2 接口定义与多态调度

// TaskExecutor 接口：所有任务执行器必须实现
type TaskExecutor interface {
    Execute(ctx context.Context, params map[string]interface{}) (interface{}, error)
    Validate() error
}

// 具体实现：Shell 任务执行器
type ShellExecutor struct {
    Command string
    Args    []string
}

func (e *ShellExecutor) Execute(ctx context.Context, params map[string]interface{}) (interface{}, error) {
    cmd := exec.CommandContext(ctx, e.Command, e.Args...)
    output, err := cmd.CombinedOutput()
    return string(output), err
}

func (e *ShellExecutor) Validate() error {
    if e.Command == "" {
        return fmt.Errorf("shell command cannot be empty")
    }
    return nil
}

// 具体实现：HTTP 任务执行器
type HTTPExecutor struct {
    URL     string
    Method  string
    Headers map[string]string
}

func (e *HTTPExecutor) Execute(ctx context.Context, params map[string]interface{}) (interface{}, error) {
    req, _ := http.NewRequestWithContext(ctx, e.Method, e.URL, nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    return string(body), nil
}

func (e *HTTPExecutor) Validate() error {
    if e.URL == "" {
        return fmt.Errorf("HTTP URL cannot be empty")
    }
    return nil
}
调度架构要点：接口 TaskExecutor 使得调度器无需关心具体任务类型。新增任务类型只需实现接口，无需修改调度核心逻辑。这是 DAG 调度引擎可扩展性的关键设计。

3.5 类型系统与调度核心的映射关系

下表总结了 Go 基础语法元素与 DAG 调度实现之间的直接映射：

Go 语法元素 调度实现映射 关键作用
变量作用域 节点状态、调度上下文 避免闭包陷阱，保障并发安全
iota 常量 任务阶段枚举 类型安全的阶段转换
for-range 拓扑排序、邻接表遍历 入度计算与依赖解析
select 多路信号监听 超时、取消、完成信号聚合
defer 状态回滚、资源释放 异常安全的状态管理
函数类型 回调钩子、任务函数 生命周期扩展
结构体组合 DAGNode、DAG 定义 数据聚合与状态封装
接口 TaskExecutor 契约 多态调度与可测试性
Go 基础语法 → DAG 调度架构映射 变量 & 常量 控制结构 函数 结构体 接口 状态管理 拓扑排序 回调 & 选项 节点实体 执行器契约 核心设计原则 每个 Go 语法特性在调度器中都有明确映射，形成“语法 → 架构”的对应关系

3.6 本章小结

Go 基础语法并非孤立的知识点，而是 DAG 调度实现的直接建筑材料：

  • 变量与常量 为调度状态和配置提供类型安全的基础设施；
  • 控制结构 驱动拓扑遍历、并发信号处理和异常回滚；
  • 函数 作为一等公民实现回调机制和配置注入；
  • 结构体与接口 定义调度实体的数据模型和行为契约，支撑可扩展的调度架构。
← 上一章 📖 返回目录 下一章 →