java - 如何限制堆栈深度

Question

下面是我编写的代码的简化版本。基本上有一些对象接收消息，对它们做一些事情，然后传递它们(它们实现 IState)和发送消息的对象(它们实现 ISend)。问题是我得到非常深的堆栈跟踪，最终导致堆栈溢出。我该如何解决这个问题？

public class StackTraceMain {
    private IState origin;

    public static void main(String[] args) {        
        StackTraceMain s = new StackTraceMain();
        s.prepare();
        s.go();
    }

    public void prepare(){
        Sender sendTo2 = new Sender();
        Sender sendTo1 = new Sender();
        origin = new State(sendTo2);
        IState state2 = new State(sendTo1);
        sendTo2.setTarget(state2);
        sendTo1.setTarget(origin);
    }

    public void go(){
        origin.update(new DataTuple(0));
    }

    private class State implements IState {
        private final ISend sender;

        public State(ISend sender) {
            this.sender = sender;
        }

        @Override
        public void update(DataTuple data) {
            int num = data.getInteger(0);
            num++;
            System.out.println("Sending " + num + ", depth: " + Thread.currentThread().getStackTrace().length);
            if (num < 1000)
                sender.signal(new DataTuple(num));
        }       
    }

    private class Sender implements ISend {
        private IState target;

        public void setTarget(IState target){
            this.target = target;
        }

        @Override
        public void signal(DataTuple data) {
            target.update(data);        
        }       
    }
}

Answer 1

不使用无限递归函数调用，而是使用 SingleThreadedExecutor ，并使用它来调度更新调用。

因为这个执行器是单线程的，所以你不必担心并发操作会产生奇怪的变化。

为进行此更改，我们在应用程序开始时创建了一个全局线程池:

public final static ExecutorService GLOBAL_APPLICATION_THREAD = Executors.newSingleThreadExecutor();

然后我们将更新方法更改为:

@Override
public void update(DataTuple data) {
    GLOBAL_APPLICATION_THREAD.execute( () -> { // Create lamba function
        int num = data.getInteger(0);
        num++;
        System.out.println("Sending " + num + ", depth: " + Thread.currentThread().getStackTrace().length);
        if (num < 1000)
            sender.signal(new DataTuple(num));
        }    
    });
}

然后当您运行新创建的代码时，您会看到堆栈大小保持不变，这是因为 Executor 的成瘾性将递归展开为看起来像循环的东西，您可以在循环中添加元素。

了解其工作原理的最佳方式是了解 execute 不会直接执行它，而是将其置于待执行任务的等待行中，并且仅在整个点执行函数栈结束，会执行一个新的函数。这个Executor中的循环可以看成下面这样:

// Demonstration code only, may not feature best practices
LinkedList<Runnable> q = new LinkedList<>();
while(true) {
    Runnable task = q.remove(); // removes the first element
    task.execute()
}

当您尝试执行一个新任务时，它基本上会执行 q.add(...)，从而等待执行直到当前正在运行的任务完成。