双端队列（Deque）在ForkJoinPool 的工作窃取算法应用

ForkJoinPool 的工作窃取算法通过双端队列（Deque）实现高效的负载均衡，其存取顺序设计遵循以下核心原则：

1. 任务存储顺序（Push）

• LIFO（后进先出）策略
  当线程生成子任务时，会将新任务推入自身队列的头部（push(task)）。
  目的：
  • 最大化缓存局部性（当前线程优先执行新任务，减少上下文切换）。
  • 避免频繁的锁竞争（仅修改队列头部）。

2. 任务取出顺序（执行）

• LIFO 策略
  工作线程从自身队列的尾部（pop()）取出任务执行。
  设计动机：
  • 优先处理最新生成的任务（可能依赖父任务的结果）。
  • 与 push 操作同端，减少锁竞争。

3. 任务窃取顺序（Steal）

• FIFO（先进先出）策略
  空闲线程从其他线程队列的头部（poll()）窃取任务。
  关键优势：
  • 减少竞争：被窃取线程继续从尾部取新任务，窃取线程从头部取旧任务，两端操作可并行。
  • 避免任务饥饿：确保旧任务最终被处理。

4. 数据结构选择：双端队列（Deque）

• 底层实现：ForkJoinPool 使用自定义的 WorkQueue 类，内部通过数组实现无锁双端队列。
• 线程安全机制：
  • push/pop（同端操作）通过 CAS 保证原子性。
  • poll（跨端操作）通过短暂锁或 CAS 协调。

5. 设计目标

• 减少竞争：通过分离“生产者-消费者”和“窃取者”的访问端，降低锁冲突。
• 提高吞吐量：LIFO 减少上下文切换，FIFO 平衡负载。
• 公平性：窃取线程优先处理旧任务，防止新任务垄断资源。

6. 示例流程

7. 性能影响

• LIFO 优势：
  • 缓存友好：新任务与父任务数据局部性高。
  • 减少锁竞争：同端操作无需全局锁。
• FIFO 优势：
  • 负载均衡：避免某些线程长期空闲。
  • 防止饥饿：旧任务不会被无限期延迟。

8. 对比传统线程池

9. 源码关键逻辑（简化版）

// 任务推入队列头部（LIFO）
final void push(ForkJoinTask<?> task) {
    WorkQueue[] ws; WorkQueue q; int m;
    if ((q = getWorkQueue()) != null && (m = q.base) - q.top < 0) {
        q.array[m & q.mask] = task;
        q.base = m + 1; // 修改头部
    }
}

// 从队列尾部取出任务（LIFO）
final ForkJoinTask<?> pop() {
    WorkQueue q; ForkJoinTask<?> t;
    if ((q = getWorkQueue()) != null && (t = q.currentJoin) == null) {
        int b = q.base - 1;
        q.base = b; // 修改尾部
        return (t = q.pollAt(b)) != null ? t : localPop();
    }
    return null;
}

// 从队列头部窃取任务（FIFO）
final ForkJoinTask<?> poll() {
    WorkQueue[] ws; WorkQueue q; int m;
    if ((q = getWorkQueue()) != null && (m = q.top) > q.base) {
        ForkJoinTask<?> a = q.array[(m - 1) & q.mask];
        if (q.top == m && a != null && CAS(q.top, m, m - 1)) {
            return a; // 修改头部
        }
    }
    return null;
}

总结

ForkJoinPool 通过 LIFO 执行 + FIFO 窃取 的双端队列设计，在减少锁竞争、提升缓存利用率和实现负载均衡之间取得了平衡，使其成为处理分治算法（如并行流、递归任务）的高效工具。