StackContinuations

/**
 * The Continuation class. The API design is still in progress.
 */
class Continuation {
    /**
     * Marks the beginning of a new 'scope' in preparation for stack
     * save/resume.  Executes the given Runnable.
     *
     * @param data any user defined data to be passed from this call
     *             site to the point where {@link #resume} is called
     *             for convenience.
     * @return the Continuation object after the scope was saved
     *         into a Continuation object or null if it wasn't and
     *         simply returned
     */
    public static Object enter(Runnable r, Object data);

    /**
     * Copies the stack frames in the current scope, and stores them
     * in this object.  This method must be called in an enclosing
     * scope. Calling this method causes the stack frames in the
     * scope to suspend (including the current frame) and the enter
     * call at the entry of the current scope to return.
     *
     * @return the parameter passed to the resume call when the saved stack
     *         frames are resumed in the future.
     */
    public Object save();

    /**
     * Reactivates the stack frames saved in this object on the
     * current thread.  Overwrites the stack frames in the current
     * scope with the saved stack frames.  This method must be
     * called in an enclosing scope. Calling this method causes the
     * suspended save call to resume from the point where it was
     * suspended.
     *
     * @param rv the value to be returned from the resumed save call site.
     */
    public void resume(Object rv);
}

 1  void test() {
 2    final Continuation c = 
          new Continuation();            // First, create the continuation to store stack frames into.
 3    Runnable s = new Runnable() {      // Defines the scope for a save. This Runnable will executed in line 9.
 4      public void run() {
 5        c.save();                      // Saves the one-frame scope with the stack frame for the run() call into c.
 6        System.out.println(
              "Hello JVM Continuation"); // Prints a message.
 7      }
 8    };
 9    Continuation.enter(s, null);       // Enter the scope. The above run() executes.
                                         // Line 5 causes the enter() to return the run() without executing line 6.
10  }

 1  void test(Continuation c) {          // Suppose a continuation was saved somewhere else and is passed here. 
 2    Runnable s = new Runnable() {      // Defines the scope for a resume. This Runnable will executed in line 7.
 3      public void run() {
 4        c.resume(null);                // Resumes the given continuation.
                                         // From this point on, the current thread executes the saved continuation.
                                         // Note the rest of the run() is unreachable.
 5      }
 6    };
 7    Continuation.enter(s, null);       // Enter the scope. The above run() executes.
                                         // When the saved continuation finishes/returns, control comes back here.
 8  }

 1  void test() {
 2    final Continuation c = 
          new Continuation();            // First, create the continuation to store stack frames into.
 3    Runnable s = new Runnable() {      // Defines a scope for a save. This Runnable will be executed in line 9.
 4      public void run() {
 5        c.save();                      // Saves the one-frame scope with the stack frame for the run() call into c.
 6        System.out.println(
              "Hello JVM Continuation"); // Prints a message.
 7      }
 8    };
 9    Continuation.enter(s, null);       // Enters the scope. The above run() executes.
                                         // Line 5 causes the enter() to return without the run() executing line 6.
10    Runnable r = new Runnable() {      // Defines a scope for a resume. This Runnable will be executed in line 16.
12      public void run() {
13        c.resume(null)                 // Resumes the continuation (the stack frame of run()) from line 5 
                                         // and the execution at line 13 is thrown away.
                                         // From this point on, the current thread executes from line 6 above 
                                         // and prints "Hello JVM Continuation".
14      }
15    };
16    Continuation.enter(r, null);       // After line 6 was executed, it returns back here as if this enter() method 
                                         // had executed Runnable s instead of r.
17  }