用Java实现协同程序

Question

这个问题与我关于Java中现有协程实现的问题有关.如果我怀疑,事实证明Java中目前没有完整的协同程序实现,那么实现它们需要什么？

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

1. 您可以在后台实现"coroutines"作为线程/线程池.
2. 你可以在幕后用JVM字节码做一些棘手的事情,以使协同成为可能.
3. 所谓的"Da Vinci Machine"JVM实现具有原语,使得协程可以在没有字节码操作的情况下运行.
4. 协同程序也有各种基于JNI的方法.

我将依次解决每个人的不足之处.

基于线程的协同程序

这种"解决方案"是病态的.协同程序的重点是避免线程,锁定,内核调度等的开销.协同程序应该是轻量级的,并且只能在用户空间中执行.在具有严格限制的全倾斜螺纹方面实现它们可以消除所有优点.

JVM字节码操作

这种解决方案更实用,虽然有点难以实现.这与在C中的协同程序库中跳转到汇编语言大致相同(这是其中有多少工作),其优点是您只有一个架构可以担心并且正确.

它还将您绑定到仅在完全兼容的JVM堆栈上运行代码(例如,没有Android),除非您可以找到在非兼容堆栈上执行相同操作的方法.但是,如果您确实找到了这样做的方法,那么您现在已经将系统复杂性和测试需求翻了一番.

达芬奇机器

达芬奇机器很酷的实验,但由于它不是标准的JVM,它的功能无处不在.事实上,我怀疑大多数生产环境都会特别禁止使用达芬奇机器.因此,我可以使用它来进行很酷的实验,但不能用于我期望发布到现实世界的任何代码.

这也有类似于上面的JVM字节码操作解决方案的附加问题:将无法在替代堆栈(如Android)上工作.

JNI实施

这个解决方案在Java中实现这一点的意义重大.CPU和操作系统的每种组合都需要独立测试,每一种都是可能令人沮丧的微妙故障.或者,当然,我可以完全将自己绑定到一个平台,但这也使得用Java做事的意义完全没有实际意义.

所以...

有没有办法在不使用这四种技术之一的情况下在Java中实现协同程序？或者我会被迫使用那些闻起来最少的四个中的一个(JVM操作)？

---

编辑添加:

只是为了确保混乱载,这是一个相关的问题我的另外一个,但又不尽相同.那个人正在寻找一个现有的实施方案,以避免不必要地重新发明轮子.这是一个问题,如果另一个证明无法解决,将如何在Java中实现协同程序.目的是在不同的线程上保留不同的问题.

Answer 1

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

根据我对协同程序的理解,你通常有一个生产者和一个消费者协程(或者至少这是最常见的模式).但从语义上讲,你不希望生产者给消费者打电话,反之亦然,因为这引入了不对称性.但考虑到基于堆栈的语言的工作方式,我们需要让某人进行调用.

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

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);
        }
    }
}

当然,现在困难的部分是实现接口,特别是很难将计算分解为单独的步骤.为此,您可能需要一组完整的持久控制结构.基本思想是我们想要模拟非本地控制转移(最后它有点像我们正在模拟a 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();
}

这里的基本技巧是将局部变量移动为类变量并将范围块转换为类,这使我们能够在产生返回值后"重新输入"我们的"循环".

现在来实现我们的制作人

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();
    }
}

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

Answer 2

我建议你看一下JVM上的Kotlin协程.不过,它属于不同的类别.没有涉及字节码操作,它也适用于Android.但是,您必须在Kotlin中编写协程.好处是Kotlin专为与Java的互操作性而设计,因此您仍然可以继续使用所有Java库并在同一项目中自由组合Kotlin和Java代码,甚至将它们并排放在相同的目录中包.

本指南针对kotlinx.coroutines提供了更多示例,而协同程序设计文档则解释了所有动机,用例和实现细节.

Answer 3

Kotlin 对协程使用以下方法
（来自https://kotlinlang.org/docs/reference/coroutines.html）：

协程完全通过编译技术实现（不需要VM或OS端的支持），暂停通过代码转换工作。基本上，每个挂起函数（可能会应用优化，但我们不会在这里讨论）被转换为状态机，其中状态对应于挂起调用。在暂停之前，下一个状态与相关局部变量等一起存储在编译器生成的类的字段中。在恢复该协程时，局部变量被恢复，状态机从暂停后的状态继续进行。

挂起的协程可以作为保持其挂起状态和局部变量的对象进行存储和传递。此类对象的类型是 Continuation，这里描述的整体代码转换对应于经典的 Continuation-passing 风格。因此，挂起函数在幕后采用了一个 Continuation 类型的额外参数。

在https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md查看设计文档