简介

continuation是服务于虚拟线程的一个类，主要提供run及yield的功能，使语言可以在任意点保存执行状态并且在之后的某个点返回。功能的主要实现都是在jvm源码中，Continuation.java 仅是流程代码。

如需使用，需添加以下指令到启动到jvm option：

--add-exports java.base/jdk.internal.vm=ALL-UNNAMED

run执行路径：

run.jpg

yield执行路径：

yield.jpg

1、字段方法说明：

从结构上来看，Continuation有两个维度，一个是纵向的链表维度（存在parent及child节点），一个是横向的scope维度，相同scope的属于同一类continuation（从代码实现角度来说，scope相对于对continuation打上个tag，使得用户在需要yield时不会yield错了对象）

// unsafe实例
    private static final Unsafe U = Unsafe.getUnsafe();
    // 是否开启本地缓存
    private static final boolean PRESERVE_EXTENT_LOCAL_CACHE;
    // JavaLangAccess操作对象，主要用于对 Java 核心类库中的一些非公开方法和字段的访问
    private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
    // 实际运行的 runnable
    private final Runnable target;

    /* While the native JVM code is aware that every continuation has a scope, it is, for the most part,
     * oblivious to the continuation hierarchy. The only time this hierarchy is traversed in native code
     * is when a hierarchy of continuations is mounted on the native stack.
     */
    // scope对象，使用同一scope的Continuation可以相互之间yield
    private final ContinuationScope scope;
    // 父节点
    private Continuation parent; // null for native stack
    // 子节点
    private Continuation child; // non-null when we're yielded in a child continuation

    // 栈内存空间，在java类中没有赋值，赋值操作是在native方法中进行
    private StackChunk tail;

    // 当前Continuation是否已完成
    private boolean done;
    // 装载状态
    private volatile boolean mounted = false;
    // yield信息（可能是scope，也可能是yield的结果）
    private Object yieldInfo;
    // 
    private boolean preempted;

    private Object[] extentLocalCache;

2、RUN方法

 public final void run() {

    while (true) {
      // 装载
      mount();
      JLA.setExtentLocalCache(extentLocalCache);
      // 已完成时再调用run则抛异常
      if (done)
        throw new IllegalStateException("Continuation terminated");
      // 获取当前载体线程
      Thread t = currentCarrierThread();
      // 当parent和cild都yield时，child先于paret run时，会进入此if
      if (parent != null) {
        if (parent != JLA.getContinuation(t))
          throw new IllegalStateException();
      } else
        this.parent = JLA.getContinuation(t);
      JLA.setContinuation(t, this);

      try {
        boolean isVirtualThread = (scope == JLA.virtualThreadContinuationScope());
        // 此处判断是否存在堆栈内存空间，如不存在则说明未开始
        if (!isStarted()) { // is this the first run? (at this point we know !done)
          // enterSpecial -> enter -> enter0 -> target.run
          enterSpecial(this, false, isVirtualThread);
        } else {
          assert !isEmpty();
          enterSpecial(this, true, isVirtualThread);
        }
      } finally {
        // 此处为什么需要读写屏障
        fence();
        try {
          assert isEmpty() == done : "empty: " + isEmpty() + " done: " + done + " cont: "
              + Integer.toHexString(System.identityHashCode(this));
          //
          JLA.setContinuation(currentCarrierThread(), this.parent);
          if (parent != null)
            parent.child = null;

          postYieldCleanup();

          unmount();
          if (PRESERVE_EXTENT_LOCAL_CACHE) {
            extentLocalCache = JLA.extentLocalCache();
          } else {
            extentLocalCache = null;
          }
          JLA.setExtentLocalCache(null);
        } catch (Throwable e) {
          e.printStackTrace();
          System.exit(1);
        }
      }
      // we're now in the parent continuation

      assert yieldInfo == null || yieldInfo instanceof ContinuationScope;
      // 唯一跳出循环的点
      if (yieldInfo == null || yieldInfo == scope) {
        this.parent = null;
        this.yieldInfo = null;
        return;
      } else {
        // 进入此代码块必要条件是yieldInfo存在且不为当前的scope，既yield的scope非自身的scope
        parent.child = this;
        // 此时调用 yield0 方法，将当前的continuation及需要yield的scope传递，直到匹配到yieldInfo == scope，即链表向上查找
        parent.yield0((ContinuationScope) yieldInfo, this);
        // 断链
        parent.child = null;
      }
    }
  }
 

3、Yield方法

疑问：为什么yield方法要设计成静态的方法？（此处能充分体现scope的作用，但为何如此设计）

此处yield设计成静态方法，个人认为是想要让continuation的维度在scope上控制，而不是在实例上控制。假如我们有一个Continuationd的List对象，list中存在scope=A与scope=B的continuation实例，分别执行任务a和任务b，如果我需要暂停任务a，只需要list.stream().foreach(c → Continuation.yield(scopeA));

猜想：如果把list换成线程池，把continuation换成VirtualThread，是不是就能够对scope范围的VirtualThread进行yield？

/**
   * Suspends the current continuations up to the given scope
   *
   * @param scope The {@link ContinuationScope} to suspend
   * @return {@code true} for success; {@code false} for failure
   * @throws IllegalStateException if not currently in the given {@code scope},
   */
  public static boolean yield(ContinuationScope scope) {
    Continuation cont = JLA.getContinuation(currentCarrierThread());
    Continuation c;
    // 基于Continuation实例当前向父节点遍历，直到匹配虚拟线程类型的ContinuationScope的Continuation，如果没有匹配的Continuation会抛出异常中断流程
    // 此处其实是在校验当前Continuation链表中是否存在需要yield的scope
    for (c = cont; c != null && c.scope != scope; c = c.parent)
      ;
    if (c == null)
      throw new IllegalStateException("Not in scope " + scope);

    return cont.yield0(scope, null);
  }

    /**
   * 此方法有两个调用的地方，一个是yield，另一个是run，其中run方法中会传child
   *
   */
  private boolean yield0(ContinuationScope scope, Continuation child) {
    preempted = false;

    // 此处记录需要yield 的 scope
    if (scope != this.scope)
      this.yieldInfo = scope;
    // 该方法由c++实现，具体：stubGenerator_aarch64.cpp  → generate_cont_doYield() 方法
    // 主要作用是将当前线程的执行状态保存并返回到调用者，即真正实现yield地方
    int res = doYield();
    U.storeFence(); // needed to prevent certain transformations by the compiler

    assert scope != this.scope || yieldInfo == null
        : "scope: " + scope + " this.scope: " + this.scope + " yieldInfo: " + yieldInfo + " res: " + res;
    assert yieldInfo == null || scope == this.scope || yieldInfo instanceof Integer
        : "scope: " + scope + " this.scope: " + this.scope + " yieldInfo: " + yieldInfo + " res: " + res;

    // 此处代码的作用是将this的res传递给child，并将this.yieldInfo = null
    if (child != null) { // TODO: ugly 作者的吐槽，想看后续会怎么优化
      if (res != 0) {
        child.yieldInfo = res;
      } else if (yieldInfo != null) {
        assert yieldInfo instanceof Integer;
        child.yieldInfo = yieldInfo;
      } else {
        child.yieldInfo = res;
      }
      this.yieldInfo = null;
    } else {
      if (res == 0 && yieldInfo != null) {
        // 此处传递yieldInfo至链表最末尾的continuation
        res = (Integer) yieldInfo;
      }
      this.yieldInfo = null;

      if (res == 0)
        onContinue();
      else
        // 非 0 则说明 pinned ，抛异常
        onPinned0(res);
    }
    assert yieldInfo == null;

    return res == 0;
  }

4、实例说明

以下代码为continuation 、child1、child2组成的链表调用，在child2进行yield(scope)操作之后，会遍历链表，将当前节点yield，直至continuation实例的scope等于目标scope为止：

  public static void main(String[] args) {

        ContinuationScope scope = new ContinuationScope("example1");

        ContinuationScope scope2 = new ContinuationScope("example2");

        ContinuationScope scope3 = new ContinuationScope("example3");

        Continuation child2 = new Continuation(scope3, () -> {
            System.out.println("before scope yield");
            Continuation.yield(scope);
            System.out.println("after scope yield");
        });

        Continuation child1 = new Continuation(scope2, () -> {
            System.out.println("before child2 run");
            child2.run();
            System.out.println("after child2 run");
        });

        Continuation continuation = new Continuation(scope, () ->  {
            System.out.println("before child1 run");
            child1.run();
            System.out.println("after child1 run");
        });

        System.out.println("before run");
        continuation.run();
        System.out.println("before run again");
        continuation.run();
        System.out.println("end");

    } 

输出结果：

输出结果.jpg