2、核心概念解析：窗口（Window）、轮换（Rotation）、策略（Strategy）的定义与关系

好，咱们正式开始搭建之前，得先把三个最核心的概念掰扯清楚。很多同学学轮换窗口机制，代码写了一大堆，最后跑起来发现逻辑全乱套，说白了就是没搞懂这三个东西到底是什么、怎么配合的。

我个人习惯，在讲任何设计模式之前，先给它们打个比方。你想想看，一个轮换窗口系统，其实就像一个多窗口售票大厅。

核心比喻：窗口 = 售票柜台，轮换 = 叫号规则，策略 = 哪个柜台卖哪趟车的票。

2.1 窗口（Window）—— 承载任务的容器

窗口是什么？说白了，它就是一个用来执行任务的独立单元。在代码里，它可能是一个线程、一个协程、一个进程，甚至是一个微服务实例。但在我们的轮换窗口机制里，我更愿意把它抽象成一个“槽位”。

每个窗口都有几个关键属性：

  • ID：唯一标识，就像柜台编号 1 号、2 号。
  • 状态：空闲、忙碌、阻塞、关闭。
  • 当前任务：正在处理的东西。
  • 任务队列：排队等待的任务列表。

我在项目中遇到过一个问题：有人把窗口直接等同于线程，结果线程池一满，新任务就全部拒绝。其实窗口只是一个逻辑概念，它背后可以绑定任何执行资源。

// 一个简单的窗口定义
class Window {
  constructor(id) {
    this.id = id;
    this.status = 'idle'; // idle | busy | blocked | closed
    this.currentTask = null;
    this.taskQueue = [];
  }

  assign(task) {
    this.currentTask = task;
    this.status = 'busy';
    // 执行逻辑...
  }

  release() {
    this.currentTask = null;
    this.status = 'idle';
    // 从队列取下一个任务
  }
}

我的经验：窗口的数量不是越多越好。我曾经在一个高并发项目里开了 200 个窗口，结果上下文切换开销直接把吞吐量打下来了。窗口数一般建议等于 CPU 核心数的 2 倍左右，具体要压测。

2.2 轮换（Rotation）—— 驱动系统的引擎

轮换，就是窗口切换任务的节奏和规则。它决定了什么时候该让当前窗口停下来，什么时候该换下一个窗口上。

你想想看，如果没有轮换，一个窗口霸占着资源不放，其他窗口就只能干瞪眼。轮换机制就是来解决这个问题的。

常见的轮换方式有几种：

轮换方式 触发条件 适用场景
时间片轮换 固定时间间隔 CPU 调度、UI 渲染
任务完成轮换 当前任务执行完毕 批处理、消息队列
优先级轮换 高优先级任务到达 实时系统、中断处理
负载均衡轮换 窗口负载不均 分布式系统、网关

嗯，这里要注意：轮换不是越频繁越好。轮换本身是有开销的——保存上下文、恢复状态、切换资源。我记得有一次优化一个实时数据处理系统，把轮换间隔从 10ms 改成 50ms，吞吐量反而提升了 30%。

避坑指南：我曾经在一个项目中，轮换逻辑里加了复杂的统计计算，结果轮换本身成了性能瓶颈。记住，轮换逻辑一定要轻量，它只是“叫号”的，不是“卖票”的。

2.3 策略（Strategy）—— 决策的大脑

策略，就是决定“哪个窗口该做什么事”的规则集合。它是整个轮换窗口机制里最灵活、也最容易出问题的地方。

策略通常回答三个问题：

  1. 谁来选？—— 是集中调度器，还是窗口自己抢？
  2. 选哪个？—— 按什么规则选下一个窗口？
  3. 做什么？—— 分配什么类型的任务？

我常用的策略模式实现是这样的：

// 策略接口
class RotationStrategy {
  selectWindow(windows, task) {
    throw new Error('子类必须实现 selectWindow 方法');
  }
}

// 轮询策略 - 最简单的实现
class RoundRobinStrategy extends RotationStrategy {
  constructor() {
    super();
    this.currentIndex = 0;
  }

  selectWindow(windows, task) {
    const window = windows[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % windows.length;
    return window;
  }
}

// 最少任务策略 - 负载均衡
class LeastTasksStrategy extends RotationStrategy {
  selectWindow(windows, task) {
    return windows.reduce((best, w) => 
      w.taskQueue.length < best.taskQueue.length ? w : best
    );
  }
}

关键点：策略和轮换是分离的。轮换负责“什么时候换”，策略负责“换给谁”。把这两个概念拆开，你的系统才能灵活应对各种场景。

2.4 三者的关系 —— 一张图说清楚

好，概念都讲完了，咱们用一张图把三者的关系串起来。这是我画的一张轮换窗口核心架构图，你一看就明白。

轮换窗口核心架构图 轮换窗口核心架构图 策略（Strategy） 决定“换给谁” 轮换（Rotation） 决定“什么时候换” 窗口组（Window Pool） 窗口 1 状态：空闲 窗口 2 状态：忙碌 窗口 3 状态：阻塞 任务队列（Task Queue） 策略驱动轮换，轮换调度窗口，窗口处理任务

从这张图你能看到清晰的三层结构：

  • 策略层：高高在上，做决策。它不关心具体哪个窗口在忙，只关心“按什么规则选”。
  • 轮换层：中间调度，执行切换。它接收策略的指令，然后去操作窗口。
  • 窗口层：底层干活，执行任务。它们是被动的，等着被调度。

我的建议：在实际编码时，把这三层拆成独立的模块。策略可以热插拔，轮换可以配置化，窗口可以动态扩缩。这样你的系统才能应对业务的变化。

2.5 三者协作的完整流程

光看静态结构还不够，咱们走一遍完整的协作流程，你就彻底明白了。

  1. 任务到达：一个新任务进入系统，被放入任务队列。
  2. 策略决策：策略模块根据当前规则（比如轮询、最少连接），选出一个目标窗口。
  3. 轮换触发：轮换模块检查当前窗口状态，如果目标窗口空闲，直接分配；如果忙碌，触发轮换逻辑。
  4. 窗口切换：轮换模块保存当前窗口的上下文，切换到目标窗口。
  5. 任务执行：目标窗口开始处理任务。
  6. 完成回调：任务完成后，窗口状态变回空闲，通知轮换模块可以继续调度。

注意：这个流程里最容易出问题的是第 3 步。如果轮换逻辑里没有处理好“所有窗口都忙碌”的情况，任务就会无限等待。我一般会加一个超时兜底或者拒绝策略。

2.6 小结

好了，三个核心概念讲完了。咱们再捋一遍：

  • 窗口是干活的，它只管执行任务，不问为什么。
  • 轮换是节奏，它决定什么时候切换，不关心切换给谁。
  • 策略是大脑，它决定切换给谁，不关心什么时候切。

这三者各司其职，又紧密配合。你想想看，如果把策略和轮换混在一起写，代码会变成什么样？一个函数里既要做决策又要做切换，改一个逻辑就得动整个函数，那维护起来得多痛苦。

← 上一章 📖 返回目录 下一章 →