Work-Stealing 线程池 on Dorkytiger 的小屋

全局队列的瓶颈

Mon, 01 Jan 0001 00:00:00 +0000

第一阶段实现的线程池有一个全局任务队列，所有线程共享一个 mutex。

当任务数量很大、每个任务执行时间极短时：

线程 1:          线程 2:          线程 3:
🔒 lock()        🔒 lock()        🔒 lock() ← 等着
| 取任务          | 等着             | 等着
🔓 unlock()       ...               ...
执行任务          🔒 lock()         🔒 lock()
                  | 取任务           | 等着
                  🔓 unlock()        ...
                  执行任务           🔒 lock()
                                     ...

perf 表现（100M 个微任务，每个 1μs）：

context-switches: 几乎为 0（没有阻塞）
但：mutex 的 cache line bouncing 很严重
cache-misses: 非常高（mutex 在核心间飞来飞去）

当任务极短时，取任务的锁竞争比任务本身还耗时。

Work-Stealing 的设计

Mon, 01 Jan 0001 00:00:00 +0000

Work-Stealing 的核心思想：每个线程有自己的任务队列，线程优先处理自己的任务。自己的队列空了，才去"偷"别人的。

线程 1                   线程 2                   线程 3
┌──────────────┐        ┌──────────────┐        ┌──────────────┐
│ deque<任务>   │        │ deque<任务>   │        │ deque<任务>   │
│ [t1][t2][t3] │        │ [t4][t5]     │        │ 空            │
│  ↑pop_front  │        │  ↑pop_front  │        │              │
└──────────────┘        └──────────────┘        └──────────────┘
      │                                               │
      │ 自己取自己的任务                                 │ 自己的空了，
      │ top_front 是热点                               │ 去偷别人的
      ▼                                               ▼
  执行 t1                                        从线程 2 的
                                                 尾部偷 t5

每个队列是双端队列（deque）：

自己：从 front 取任务（pop_front）——热点
别人偷：从 back 取任务（pop_back）——减少冲突

为什么自己从 front 取、别人从 back 偷？

简易 Work-Stealing 实现

Mon, 01 Jan 0001 00:00:00 +0000

class WorkStealingThreadPool {
    std::vector<std::thread> workers_;
    std::vector<std::deque<std::function<void()>>> queues_;
    std::vector<std::mutex> mtxs_;         // 每个队列一把锁
    std::atomic<bool> stop_{false};

public:
    WorkStealingThreadPool(size_t threads)
        : workers_(threads), queues_(threads), mtxs_(threads)
    {
        for (size_t i = 0; i < threads; i++) {
            workers_[i] = std::thread([this, i] { worker_loop(i); });
        }
    }

    void enqueue(size_t thread_id, std::function<void()> task) {
        std::lock_guard<std::mutex> lock(mtxs_[thread_id]);
        queues_[thread_id].push_front(std::move(task));  // 放入自己的 front
    }

    // 提交到负载最轻的线程
    void enqueue(std::function<void()> task) {
        // 找队列最短的线程
        size_t min_idx = 0;
        size_t min_size = queues_[0].size();
        for (size_t i = 1; i < queues_.size(); i++) {
            if (queues_[i].size() < min_size) {
                min_size = queues_[i].size();
                min_idx = i;
            }
        }
        enqueue(min_idx, std::move(task));
    }

private:
    void worker_loop(size_t my_id) {
        while (!stop_) {
            std::function<void()> task;
            bool found = false;

            // 1. 先看自己的队列
            {
                std::lock_guard<std::mutex> lock(mtxs_[my_id]);
                if (!queues_[my_id].empty()) {
                    task = std::move(queues_[my_id].front());
                    queues_[my_id].pop_front();
                    found = true;
                }
            }
            if (found) { task(); continue; }

            // 2. 自己队列空，开始偷取
            for (size_t i = 0; i < queues_.size(); i++) {
                size_t victim = (my_id + 1 + i) % queues_.size();
                if (victim == my_id) continue;

                std::lock_guard<std::mutex> lock(mtxs_[victim]);
                if (!queues_[victim].empty()) {
                    task = std::move(queues_[victim].back());
                    queues_[victim].pop_back();
                    found = true;
                    break;
                }
            }
            if (found) { task(); continue; }

            // 3. 所有队列都空，让出 CPU
            std::this_thread::yield();
        }
    }
};

这个实现有个问题：没有用条件变量。空等时线程会不断 yield，浪费 CPU。工业级 Work-Stealing 通常加一个全局条件变量做"所有队列空了就休眠，有新任务就唤醒所有"的机制。

全局队列 vs Work-Stealing 对比

Mon, 01 Jan 0001 00:00:00 +0000

对比	全局队列	Work-Stealing
实现复杂度	简单	复杂
每个任务的取队列开销	1 次锁争用	极少争用（自己队列无竞争）
负载均衡	自然均衡（谁抢到谁做）	需要偷取来均衡
缓存局部性	差（任务被随机线程执行）	好（自己入队的任务自己执行）
适用场景	任务执行时间不固定	任务短小、频率高

什么时候用 Work-Stealing？

你的 SimpleAsyncLogger 那种场景——生产者线程写入日志（微任务），刷盘线程消费——是 SPSC，不需要 Work-Stealing。Work-Stealing 真正有用的是计算密集型的、任务大量且短小的并行计算，比如浏览器渲染引擎（Chromium 的 Blink 线程池就是 Work-Stealing）。