Java 如何限制堆栈深度

下面是我编写的代码的简化版本。基本上，有些对象接收消息，对它们执行一些操作，然后将它们传递（它们实现

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

公共类StackTraceMain{
私人来源；
公共静态void main（字符串[]args）{
StackTraceMain s=新的StackTraceMain（）；
s、 准备（）；
s、 go（）；
}
公众假期准备（）{
Sender sendTo2=新的Sender（）；
发送方sendTo1=新发送方（）；
原点=新状态（sendTo2）；
IState state2=新状态（sendTo1）；
sendTo2.setTarget（state2）；
sendTo1.setTarget（原点）；
}
公开作废go（）{
更新（新的数据元组（0））；
}
私有类状态实现IState{
私人最终ISend发送者；
公共状态（ISend发送方）{
this.sender=发送方；
}
@凌驾
公共无效更新（数据元组数据）{
int num=data.getInteger（0）；
num++；
System.out.println（“发送”+num+”，深度：+Thread.currentThread（）.getStackTrace（）.length）；
如果（数值<1000）
sender.signal（新数据元组（num））；
}       
}
私有类发送器实现ISend{
私人目标；
公共无效设置目标（IState目标）{
this.target=目标；
}
@凌驾
公共无效信号（数据元组数据）{
更新（数据）；
}       
}
}

您可以通过更改java应用程序（或应用程序服务器）的参数

-Xss

来防止堆栈溢出

---

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

而不是使用无限递归函数调用，使用a，并使用该函数分派更新调用

因为这个执行器是单线程的，所以您不必担心并发操作会做出奇怪的更改

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

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

---

当您尝试执行新任务时，它基本上执行

q.add（…）

，并等待执行，直到当前正在运行的任务完成。

我同意需要执行一些更改，但我不确定是哪一个。有两个

IState

对象必须反复作用于同一条消息。到达异常需要很长时间，因此我需要花一些时间发布它。为什么使用不同的事件总线会有帮助？@Johnny编辑了这篇文章，只需将

Executor

作为一个列表，您可以将runnable添加到其中，并使用一个专用线程从中读取所有任务，

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