4. FIFO调度：先来先服务策略的原理、优缺点分析、适用场景

说到调度策略，FIFO（First In First Out）是最简单、最直观的一种。说白了就是谁先来谁先上，跟排队买奶茶一个道理。我刚开始接触分布式调度时，觉得这玩意儿太简单了，没什么好讲的。后来在项目中踩过坑才发现，越是简单的策略，用对了地方反而最稳。

4.1 原理：排队到底

FIFO的核心思想就一条：任务按提交顺序依次执行。系统维护一个任务队列，新来的任务排到队尾，调度器从队头取任务执行。

嗯，这里要注意：FIFO不关心任务优先级，不关心任务大小，也不关心资源需求。它只认一个东西——时间戳。

我画了一张流程图，帮你理解FIFO的完整调度过程：

你看，整个过程就是一个闭环。任务提交后排队，调度器按顺序取出执行，执行完再取下一个。简单到不能再简单。

4.2 优缺点分析

任何调度策略都有两面性。FIFO的优点和缺点都非常鲜明，我一个个说。

优点

• 实现极其简单：一个队列就够了，不需要复杂的优先级计算或资源匹配逻辑。我当年用Redis的List结构就实现过一个轻量级FIFO调度器，代码不到50行。
• 公平性有保障：每个任务都能被调度到，不会出现饥饿现象。你想想看，只要排队，早晚轮到你。
• 开销极低：调度决策的时间复杂度是O(1)，就是取队头元素。对于高吞吐场景，这个优势很明显。
• 可预测性强：任务的执行顺序是确定的，方便做依赖管理和流程编排。

缺点

• 短任务被长任务阻塞：这是FIFO最大的痛点。一个大任务在前面跑，后面所有小任务都得等着。我在项目中遇到过，一个数据清洗任务跑了3小时，后面几十个秒级查询任务全部排队，用户体验极差。
• 无法区分优先级：紧急任务不能插队。比如线上故障需要立即执行修复脚本，但前面排着100个离线分析任务，你只能干瞪眼。
• 资源利用率不高：如果大任务独占资源，其他资源可能空闲。比如一个任务只需要1核CPU，但集群有16核，剩下的15核全浪费了。
• 缺乏弹性：不能根据系统负载动态调整调度策略。负载高时，新任务只能排队，没有降级或熔断机制。

4.3 适用场景

FIFO不是万能的，但在某些场景下，它反而是最优解。我根据自己的经验，总结了几个典型场景：

场景	为什么适合FIFO	注意事项
任务执行时间相近	不会出现短任务被长任务阻塞	需要评估任务执行时间的方差
任务无优先级差异	所有任务同等重要，不需要插队	业务上确认确实无优先级需求
单机/小规模集群	调度开销低，实现简单	节点数不超过10台
批处理流水线	严格按顺序处理，依赖关系清晰	需要保证任务幂等性
日志/事件处理	按时间顺序处理，保证时序一致性	注意处理速度要跟上生产速度

4.4 避坑指南

我曾经在一个日志采集系统中用了FIFO调度，结果出了大问题。这里分享几个教训：

• 任务超时处理：FIFO队列中如果某个任务卡住了，后面的任务全部阻塞。一定要加超时机制，超时任务单独处理或重试。
• 队列长度监控：队列太长说明消费能力跟不上。我建议设置告警阈值，比如队列长度超过1000就报警。
• 不要用于实时系统：FIFO无法保证响应时间，不适合对延迟敏感的场景。比如交易系统、在线推荐等。
• 考虑任务依赖：如果任务B依赖任务A的结果，FIFO天然保证A先执行。但如果有循环依赖，FIFO也救不了你。

4.5 代码示例：一个简单的FIFO调度器

我写了一个极简的FIFO调度器实现，用Python演示核心逻辑。你可以在本地跑一下试试：

import queue
import time
import threading

class FIFOScheduler:
    def __init__(self):
        self.task_queue = queue.Queue()
        self.running = False
    
    def submit(self, task_id, task_func, *args, **kwargs):
        """提交任务到队列尾部"""
        self.task_queue.put({
            'id': task_id,
            'func': task_func,
            'args': args,
            'kwargs': kwargs,
            'submit_time': time.time()
        })
        print(f"[提交] 任务 {task_id} 已入队，当前队列长度: {self.task_queue.qsize()}")
    
    def start(self):
        """启动调度器，按FIFO顺序执行任务"""
        self.running = True
        while self.running:
            try:
                # 从队头取任务，阻塞等待
                task = self.task_queue.get(timeout=1)
                print(f"[调度] 开始执行任务 {task['id']}，等待时间: {time.time() - task['submit_time']:.2f}s")
                # 执行任务
                task['func'](*task['args'], **task['kwargs'])
                print(f"[完成] 任务 {task['id']} 执行完毕")
                self.task_queue.task_done()
            except queue.Empty:
                continue
    
    def stop(self):
        self.running = False

# 使用示例
def my_task(name, duration):
    print(f"  任务 {name} 开始执行，预计耗时 {duration}s")
    time.sleep(duration)
    print(f"  任务 {name} 执行完成")

if __name__ == "__main__":
    scheduler = FIFOScheduler()
    
    # 启动调度器线程
    t = threading.Thread(target=scheduler.start, daemon=True)
    t.start()
    
    # 提交任务
    scheduler.submit("T1", my_task, "T1", 2)
    scheduler.submit("T2", my_task, "T2", 1)
    scheduler.submit("T3", my_task, "T3", 3)
    
    # 等待所有任务完成
    time.sleep(10)
    scheduler.stop()

运行这段代码，你会看到T1先执行，然后T2，最后T3。即使T2只需要1秒，它也得等T1跑完2秒才能开始。这就是FIFO的典型表现。

好了，FIFO调度就讲到这里。记住一句话：简单不等于没用，关键是用对地方。下一节我们会聊优先级调度，看看怎么解决FIFO「一视同仁」带来的问题。

---

想要更多资料，联系可可