java - 在 Java 中实现协程

Question

这个问题与我在 existing coroutine implementations in Java 上的问题有关。 .如果，正如我所怀疑的那样，Java 中目前没有完整的协程实现，那么实现它们需要什么？

正如我在那个问题中所说，我知道以下内容:

1. 您可以在后台将“协程”实现为线程/线程池。
2. 您可以在后台使用 JVM 字节码做一些棘手的事情，以使协同程序成为可能。
3. 所谓的“达芬奇机器”JVM 实现具有使协程无需 字节码操作。
4. 还有各种基于 JNI 的协程方法。

我会依次解决每个人的不足之处。

基于线程的协程

这种“解决方案”是病态的。协程的全部意义在于避免线程、锁定、内核调度等的开销。协程应该轻巧快速并且只在用户空间中执行。用严格限制的全倾斜线程来实现它们会消除所有优势。

JVM 字节码操作

这个解决方案更实用，虽然有点难以实现。这与在 C 中跳入协程库的汇编语言大致相同(这是其中有多少可以工作)，其优势在于您只需担心一种架构即可。

它还将您限制为仅在完全兼容的 JVM 堆栈(例如，没有 Android)上运行您的代码，除非您能找到一种方法在不兼容的堆栈上执行相同的操作。但是，如果您确实找到了这样做的方法，那么您现在的系统复杂性和测试需求就会增加一倍。

达芬奇机器

达芬奇机器非常适合实验，但由于它不是标准的 JVM，它的功能不会随处可用。事实上，我怀疑大多数生产环境都会明确禁止使用达芬奇机器。因此，我可以用它来做很酷的实验，但不能用于我希望发布到现实世界的任何代码。

这还有一个类似于上面的 JVM 字节码操作解决方案的附加问题:不适用于替代堆栈(如 Android 的)。

JNI 实现

这个解决方案使得在 Java 中这样做的意义完全没有实际意义。 CPU 和操作系统的每种组合都需要独立测试，并且每种组合都可能导致令人沮丧的细微故障。或者，当然，我可以将自己完全束缚在一个平台上，但这也使得在 Java 中做事的意义完全没有意义。

所以...

有没有什么方法可以在不使用这四种技术之一的情况下在 Java 中实现协程？还是我会被迫改用这四种气味中最难闻的一种(JVM 操作)？

---

编辑添加:

只是为了确保避免混淆，这是一个与 my other one 相关的问题。 ，但不一样。那个人正在寻找一个现有的实现，以避免不必要地重新发明轮子。这个问题与如果另一个证明无法回答，一个人将如何在 Java 中实现协程有关。目的是在不同的线程上保留不同的问题。

Answer 1

我会看看这个:http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html ，它非常有趣，应该提供一个很好的起点。但是当然我们使用的是 Java，所以我们可以做得更好(或者可能更糟，因为没有宏:))

根据我对协程的理解，您通常有一个 producer 和一个 consumer 协程(或者至少这是最常见的模式)。但是从语义上讲，您不希望生产者调用消费者或反之亦然，因为这会引入不对称性。但考虑到基于堆栈的语言的工作方式，我们需要有人进行调用。

所以这里有一个非常简单的类型层次结构:

public interface CoroutineProducer<T>
{
    public T Produce();
    public boolean isDone();
}

public interface CoroutineConsumer<T>
{
    public void Consume(T t);
}

public class CoroutineManager
{
    public static Execute<T>(CoroutineProducer<T> prod, CoroutineConsumer<T> con)
    {
        while(!prod.IsDone()) // really simple
        {
            T d = prod.Produce();
            con.Consume(d);
        }
    }
}

当然，困难的部分是实现接口(interface)，特别是很难将计算分解为单独的步骤。为此，您可能需要一整套持久控制结构。基本思想是我们想要模拟控制的非本地转移(最终有点像我们在模拟 goto)。我们基本上希望通过将当前操作的状态保持在堆中而不是堆栈中来摆脱使用堆栈和 pc(程序计数器)。因此我们需要一堆帮助类。

例如:

假设在理想世界中，您想编写一个看起来像这样的消费者(伪代码):

boolean is_done;
int other_state;
while(!is_done)
{
    //read input
    //parse input
    //yield input to coroutine
    //update is_done and other_state;
}

我们需要抽象像 is_done 和 other_state 这样的局部变量，并且我们需要抽象 while 循环本身，因为我们的 yield 类操作是不会使用堆栈。所以让我们创建一个while循环抽象和相关的类:

enum WhileState {BREAK, CONTINUE, YIELD}
abstract class WhileLoop<T>
{
    private boolean is_done;
    public boolean isDone() { return is_done;}
    private T rval;
    public T getReturnValue() {return rval;} 
    protected void setReturnValue(T val)
    {
        rval = val;
    }


    public T loop()
    {
        while(true)
        {
            WhileState state = execute();
            if(state == WhileState.YIELD)
                return getReturnValue();
            else if(state == WhileState.BREAK)
                    {
                       is_done = true;
                return null;
                    }
        }
    }
    protected abstract WhileState execute();
}

这里的基本技巧是将 local 变量移动为 class 变量并将范围 block 转换为类，这使我们能够“重新进入”我们的“循环” ' 在产生我们的返回值之后。

现在实现我们的生产者

public class SampleProducer : CoroutineProducer<Object>
{
    private WhileLoop<Object> loop;//our control structures become state!!
    public SampleProducer()
    {
        loop = new WhileLoop()
        {
            private int other_state;//our local variables become state of the control structure
            protected WhileState execute() 
            {
                //this implements a single iteration of the loop
                if(is_done) return WhileState.BREAK;
                //read input
                //parse input
                Object calcluated_value = ...;
                //update is_done, figure out if we want to continue
                setReturnValue(calculated_value);
                return WhileState.YIELD;
            }
        };
    }
    public Object Produce()
    {
        Object val = loop.loop();
        return val;
    }
    public boolean isDone()
    {
        //we are done when the loop has exited
        return loop.isDone();
    }
}

类似的技巧可以用于其他基本的控制流结构。理想情况下，您将构建这些帮助类的库，然后使用它们来实现这些简单的接口(interface)，最终将为您提供协同例程的语义。我确信我在这里写的所有内容都可以概括和扩展。