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(...)，因此在当前运行任务完成之前等待执行。

Answer 2

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

如果您有太多深度调用，并且无法找到堆栈维度的合理值来阻止stackOverflow 您需要重新启动应用程序以删除某些调用< / strong>即可。例如您可以将递归函数转换为标准循环。

如何限制堆栈深度

2 个答案: