如何限制堆栈深度

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

您可以通过更改 java 应用程序（或您的应用程序服务器）的参数 -Xss 来防止 Whosebug。

如果您 深度调用太多 并且无法找到合理的堆栈维度值来防止堆栈溢出 您需要重新设计您的应用程序删除某些调用。例如您可以将递归函数转换为标准循环。

Answer 2

不使用无限递归函数调用，而是使用 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(...)，因此会等待执行，直到当前运行ning 任务完成。

如何限制堆栈深度

How to limit the stack depth

java

stack-overflow