Question

是否有可能创建一种方法，可以通过“返回”暂时暂停，然后在再次调用时恢复？它应该表现得好像从未返回（即保留所有变量，继续执行下一行等）。

public static void main(String args) {
   method(); //should start method
   //do stuff ONLY AFTER method() RETURNS
   method(); //should continue method at same place as it ended
   //do more stuff ONLY AFTER method() RETURNS
}

private static void method() {
   while(true) {
        //do stuff
        return;

        //do different stuff
        return;

        //do a third thing
        return;

        //then start all over
    }
}

我在StackOverflow上看到了几个类似的问题，但没有一个答案看起来足够或解释。

Answer 1

我认为你是以错误的方式处理问题，但是如果你坚持，你可以将状态作为参数传递给方法或将方法放在不同的类中并将状态保持为实例变量

Answer 2

您要查找的内容类似于C＃的yield return语句： http://msdn.microsoft.com/en-us/library/9k7k7cf0.aspx

据我所知，Java没有类似的构造。如果你真的绝望而且不羞于繁重的字节码操作，你可以自己动手：

首先使用名为yieldReturn（）的静态方法创建一个类。然后，您可以在所有类中搜索对该方法的调用，并按照http://csharpindepth.com/articles/chapter6/iteratorblockimplementation.aspx

的顺序执行修改

Answer 3

我没有在java中看到任何有效的延续实现，但还有另一种方法可以帮助你。

Actors（例如Akka）可用于实现有限状态机，特别是因为它们“切换上下文”和“成为”另一个状态。

有效地，每个方法都会操纵状态，在结束之前，actor会切换到这个增强状态。

与延续相比，我发现这种方法很容易，这可能有些神秘。

Answer 4

由于它被标记为'miltithreading'，我猜'经典'的方式是将'method（）'线程化，使其成为无限循环，而不是使用wait / notify或condvars，而不是call / return，或者用于交换流'令牌'的二进制信号量。

Answer 5

您可以仿效这样的协程：

class Coruntine extends Thread {
    Semaphore in = new Semaphore(0);
    Semaphore out = new Semaphore(0);
    boolean started=false;

    public Coruntine() {
        super.setDaemon(true);
    }

    public void method() {
        if (started) {
           in.release();
        } else {
            started=true;
            start();
        }
        try {
            out.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void _return() {
        out.release();
        try {
            in.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void run() {
        while (true) {
            System.out.println("do stuff 1");
            _return(); // like return

            System.out.println("do stuff 2");
            _return();

            System.out.println("do stuff 3");
            _return();

            // then start all over
        }
    }
}

public static void main(String[] args) {
    Coruntine c = new Coruntine();
    c.method(); // should start method
    System.out.println("do stuff AFTER method() RETURNS 1");
    c.method(); // should continue method at same place as it ended
    System.out.println("do stuff AFTER method() RETURNS 2");
    c.method(); // should continue method at same place as it ended
    System.out.println("do stuff AFTER method() RETURNS 3");
    c.method(); // should continue method at same place as it ended
    System.out.println("do stuff AFTER method() RETURNS 4");
}

如果method()应返回值和/或接受参数，请使用阻塞队列而不是信号量。

暂时暂停一个方法直到下次通话

5 个答案: