死磕 java同步系列之Phaser源码解析

问题

（1）Phaser是什么？

（2）Phaser具有哪些特性？

（3）Phaser相对于CyclicBarrier和CountDownLatch的优势？

简介

Phaser，翻译为阶段，它适用于这样一种场景，一个大任务可以分为多个阶段完成，且每个阶段的任务可以多个线程并发执行，但是必须上一个阶段的任务都完成了才可以执行下一个阶段的任务。

这种场景虽然使用CyclicBarrier或者CountryDownLatch也可以实现，但是要复杂的多。首先，具体需要多少个阶段是可能会变的，其次，每个阶段的任务数也可能会变的。相比于CyclicBarrier和CountDownLatch，Phaser更加灵活更加方便。

使用方法

下面我们看一个最简单的使用案例：

public class PhaserTest {
   

    public static final int PARTIES = 3;
    public static final int PHASES = 4;

    public static void main(String[] args) {
   

        Phaser phaser = new Phaser(PARTIES) {
   
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
   
                // 【本篇文章由公众号“彤哥读源码”原创，请支持原创，谢谢！】
                System.out.println("=======phase: "   phase   " finished=============");
                return super.onAdvance(phase, registeredParties);
            }
        };

        for (int i = 0; i < PARTIES; i  ) {
   
            new Thread(()->{
   
                for (int j = 0; j < PHASES; j  ) {
   
                    System.out.println(String.format("%s: phase: %d", Thread.currentThread().getName(), j));
                    phaser.arriveAndAwaitAdvance();
                }
            }, "Thread "   i).start();
        }
    }
}

这里我们定义一个需要4个阶段完成的大任务，每个阶段需要3个小任务，针对这些小任务，我们分别起3个线程来执行这些小任务，查看输出结果为：

Thread 0: phase: 0
Thread 2: phase: 0
Thread 1: phase: 0
=======phase: 0 finished=============
Thread 2: phase: 1
Thread 0: phase: 1
Thread 1: phase: 1
=======phase: 1 finished=============
Thread 1: phase: 2
Thread 0: phase: 2
Thread 2: phase: 2
=======phase: 2 finished=============
Thread 0: phase: 3
Thread 2: phase: 3
Thread 1: phase: 3
=======phase: 3 finished=============

可以看到，每个阶段都是三个线程都完成了才进入下一个阶段。这是怎么实现的呢，让我们一起来学习吧。

原理猜测

根据我们前面学习AQS的原理，大概猜测一下Phaser的实现原理。

首先，需要存储当前阶段phase、当前阶段的任务数（参与者）parties、未完成参与者的数量，这三个变量我们可以放在一个变量state中存储。

其次，需要一个队列存储先完成的参与者，当最后一个参与者完成任务时，需要唤醒队列中的参与者。

嗯，差不多就是这样子。

结合上面的案例带入：

初始时当前阶段为0，参与者数为3个，未完成参与者数为3；

第一个线程执行到phaser.arriveAndAwaitAdvance();时进入队列；

第二个线程执行到phaser.arriveAndAwaitAdvance();时进入队列；

第三个线程执行到phaser.arriveAndAwaitAdvance();时先执行这个阶段的总结onAdvance()，再唤醒前面两个线程继续执行下一个阶段的任务。

嗯，整体能说得通，至于是不是这样呢，让我们一起来看源码吧。

源码分析

主要内部类

static final class QNode implements ForkJoinPool.ManagedBlocker {
   
    final Phaser phaser;
    final int phase;
    final boolean interruptible;
    final boolean timed;
    boolean wasInterrupted;
    long nanos;
    final long deadline;
    volatile Thread thread; // nulled to cancel wait
    QNode next;

    QNode(Phaser phaser, int phase, boolean interruptible,
          boolean timed, long nanos) {
   
        this.phaser = phaser;
        this.phase = phase;
        this.interruptible = interruptible;
        this.nanos = nanos;
        this.timed = timed;
        this.deadline = timed ? System.nanoTime()   nanos : 0L;
        thread = Thread.currentThread();
    }
}

先完成的参与者放入队列中的节点，这里我们只需要关注thread和next两个属性即可，很明显这是一个单链表，存储着入队的线程。

主要属性

// 状态变量，用于存储当前阶段phase、参与者数parties、未完成的参与者数unarrived_count
private volatile long state;
// 最多可以有多少个参与者，即每个阶段最多有多少个任务
private static final int  MAX_PARTIES     = 0xffff;
// 最多可以有多少阶段
private static final int  MAX_PHASE       = Integer.MAX_VALUE;
// 参与者数量的偏移量
private static final int  PARTIES_SHIFT   = 16;
// 当前阶段的偏移量
private static final int  PHASE_SHIFT