并发模式

通道与消息传递

用有界 channel / mailbox 把「谁写谁读」钉死：单消费者或多消费者要显式；关闭语义与「零值可读」陷阱（如 Go）写进评审清单。CSP 风格适合流水线；actor 适合封装可变状态的单点写入。

• 优先消息传递；必须共享内存时，缩小为只读快照或 copy-on-write。
• 扇出：为每一跳设独立缓冲与超时，避免一头慢拖死全局。

Go Worker Pool 与 Node.js worker_threads 实现：

// === Go Worker Pool（有界 goroutine 池）===
func workerPool(ctx context.Context, jobs <-chan Job, numWorkers int) {
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for {
                select {
                case job, ok := <-jobs:
                    if !ok return  // channel 关闭，退出
                    process(job)
                case <-ctx.Done():
                    return  // 上下文取消，退出
                }
            }
        }()
    }
    wg.Wait()
}

// 背压：队列满时阻塞提交（有界 channel 天然背压）
jobs := make(chan Job, 100)  // 缓冲 100，超出则阻塞 send
go func() {
    for _, j := range allJobs {
        select {
        case jobs <- j:   // 队满则阻塞，产生背压
        case <-ctx.Done(): return
        }
    }
    close(jobs)
}()

// === Node.js worker_threads Pool（CPU 密集任务）===
const { Worker, workerData, parentPort, isMainThread } = require("worker_threads");
// worker.js
if (!isMainThread) {
  parentPort.on("message", (data) => {
    const result = heavyCompute(data);
    parentPort.postMessage(result);
  });
}
// main.js：创建 4 个 worker
const workers = Array.from({ length: 4 }, () =>
  new Worker(__filename)
);
let idx = 0;
function runOnWorker(data) {
  return new Promise((resolve, reject) => {
    const w = workers[idx++ % workers.length];
    w.once("message", resolve);
    w.once("error", reject);
    w.postMessage(data);
  });
}

锁与临界区

互斥锁保护不变量；读写锁适合读多写少但要警惕写饥饿。分段锁降低争用，却增加死锁面——锁顺序必须全局一致。分布式场景用租约、fence token 或版本列，而不是拉长本地临界区。

• 默认拒绝「为并发而并发」：先证明热点再并行化。
• 新模式上线前与 竞态条件排查 联动做压测矩阵。

Semaphore（限制并发数量）实现示例：

// Node.js Semaphore：限制同时并发的 async 操作数量
class Semaphore {
  constructor(max) {
    this.max = max;
    this.count = 0;
    this.queue = [];
  }
  acquire() {
    return new Promise((resolve) => {
      if (this.count < this.max) {
        this.count++;
        resolve();
      } else {
        this.queue.push(resolve);  // 背压：排队等待
      }
    });
  }
  release() {
    this.count--;
    if (this.queue.length > 0) {
      this.count++;
      const next = this.queue.shift();
      next();
    }
  }
  async run(fn) {
    await this.acquire();
    try { return await fn(); }
    finally { this.release(); }
  }
}

// 使用：最多 5 个并发 HTTP 请求
const sem = new Semaphore(5);
const results = await Promise.all(
  urls.map(url => sem.run(() => fetch(url)))
);

异步与管线

事件循环上避免阻塞；CPU 段交给池或子进程。async pipeline 用 async 生成器、队列或 Rx 式操作符时，要为每级设并发上限（如 map 并发度）。扇入收集需 errgroup 式错误聚合与短路取消。

• 背压：阻塞、限速、丢样、降级或反馈上游；四选一写进 spec。
• 取消：context / AbortSignal 贯穿；勿在关闭后仍往通道写。

Circuit Breaker 状态机实现（三态：Closed / Open / Half-Open）：

// Circuit Breaker 状态机（Node.js）
const STATE = { CLOSED: "CLOSED", OPEN: "OPEN", HALF_OPEN: "HALF_OPEN" };

class CircuitBreaker {
  constructor(opts = {}) {
    this.failureThreshold = opts.failureThreshold ?? 5;
    this.recoveryTimeout = opts.recoveryTimeout ?? 30_000;
    this.state = STATE.CLOSED;
    this.failures = 0;
    this.nextAttempt = 0;
  }

  async call(fn) {
    if (this.state === STATE.OPEN) {
      if (Date.now() < this.nextAttempt)
        throw new Error("Circuit OPEN: 拒绝请求");
      this.state = STATE.HALF_OPEN;  // 进入探测状态
    }
    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (err) {
      this.onFailure();
      throw err;
    }
  }

  onSuccess() {
    this.failures = 0;
    this.state = STATE.CLOSED;
  }

  onFailure() {
    this.failures++;
    if (this.failures >= this.failureThreshold || this.state === STATE.HALF_OPEN) {
      this.state = STATE.OPEN;
      this.nextAttempt = Date.now() + this.recoveryTimeout;
    }
  }
}

// 使用
const cb = new CircuitBreaker({ failureThreshold: 3, recoveryTimeout: 10_000 });
const data = await cb.call(() => fetch("https://api.example.com/data"));

选型主流程（skill-flow-block）

把下面流程当作 PR 描述或 Agent 计划骨架：先定资源与 SLA，再定结构，最后才调池宽与队列。

  [ 工作负载：CPU / I/O / 混合 / 强一致协调 ]
                    │
                    ▼
         ┌──────────────────────┐
         │  状态落点在哪里？      │
         │  单点 / 分片 / 无共享   │
         └──────────────────────┘
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
  [ 消息通道    [ 锁/分段    [ 纯异步管线
     actor ]      临界区 ]     + 池 offload ]
        │           │           │
        └───────────┼───────────┘
                    ▼
         [ 有界队列 + 背压策略（阻塞/限速/丢样/降级）]
                    │
                    ▼
         [ 取消/超时沿调用链传播 + 指标：队列深 / 年龄 / p95 ]
                    │
                    ▼
              [ 压测与竞态矩阵 ]

模式建议器

下列组合仅作设计速写，不替代 profiling。拖动「并行度意图」可粗调建议文案（纯前端计算，不落盘）。