如何获取 StackOverflowError 的完整堆栈

Question

当观察 StackOverflowError 时如何检索完整的调用堆栈？

考虑这个简单的例子：

public class Overflow {

    public Overflow() {
        new Overflow();
    }
    public static void a() {
        new Overflow();
    }
    public static void main(String[] argv) {
        a();
    }
}

现在报告的错误是：

Exception in thread "main" java.lang.StackOverflowError
    at Overflow.<init>(Overflow.java:11)
    [last line repeated many times]

But I can't see the main and a堆栈跟踪中的 方法。我的猜测是这是因为溢出，堆栈上的最新条目替换了最旧的条目（？）。

现在，如何获取输出中的 a 和 main 堆栈条目？

背景是我得到了 StackOverflowError （但这不是无限递归，因为增加堆栈大小时不会发生）并且很难在代码中发现问题。我只从 java.util.regex.Pattern 中获取多行，但没有获取代码调用该内容的信息。该应用程序太复杂，无法在每次调用 Pattern 时设置断点。

Answer 1

JVM 人为限制异常或错误的堆栈跟踪中可以有 1024 个条目，可能是为了在发生异常或错误时节省内存（因为 VM 必须分配内存来存储堆栈跟踪）。

幸运的是，有一个标志可以增加这个限制。只需使用以下参数运行您的程序：

-XX:MaxJavaStackTraceDepth=1000000

这将打印最多 100 万条堆栈跟踪条目，这应该足够了。也可以将此值设置为0，以将条目数量设置为无限制。

此列表非 -标准 JVM 选项 提供了更多详细信息：

最大。不。 Java 异常的堆栈跟踪中的行数（0 表示
全部）。使用Java> 1.6，值 0 实际表示 0。值 -1 或任意
必须指定负数才能打印所有堆栈（用
Windows 上为 1.6.0_22、1.7.0）。对于 Java <= 1.5，值 0 意味着一切，JVM 因负数而阻塞（在 1.5.0_22 上测试）
Windows）。

使用此标志运行问题示例会得到以下结果：

Exception in thread "main" java.lang.StackOverflowError
    at Overflow.<init>(Overflow.java:3)
    at Overflow.<init>(Overflow.java:4)
    at Overflow.<init>(Overflow.java:4)
    at Overflow.<init>(Overflow.java:4)
(more than ten thousand lines later:)
    at Overflow.<init>(Overflow.java:4)
    at Overflow.<init>(Overflow.java:4)
    at Overflow.a(Overflow.java:7)
    at Overflow.main(Overflow.java:10)

这样，即使实际堆栈跟踪长度超过 1024 行，您也可以找到引发错误的代码的原始调用者。

如果您无法使用该选项，那么还有另一种方法，如果您处于这样的递归函数中，并且可以修改它。如果添加以下 try-catch：

public Overflow() {
    try {
        new Overflow();
    }
    catch(StackOverflowError e) {
        StackTraceElement[] stackTrace = e.getStackTrace();
        // if the stack trace length is at  the limit , throw a new StackOverflowError, which will have one entry less in it.
        if (stackTrace.length == 1024) {
            throw new StackOverflowError();
        }
        throw e;  // if it is small enough, just rethrow it.
    }
}

本质上，这将创建并抛出一个新的 StackOverflowError，丢弃最后一个条目，因为每个条目都会比前一个条目向上发送一级（这可能需要几秒钟，因为必须创建所有这些错误）。当堆栈跟踪减少到 1023 个元素时，只需重新抛出即可。

最终，这将在堆栈跟踪底部打印 1023 行，这不是完整的堆栈跟踪，但可能是其中最有用的部分。

Answer 2

据我所知，不可能获得完整的堆栈跟踪（但是，我真的不知道为什么）。

但是，您可以采取的措施来追踪问题，就是手动检查受影响代码中的堆栈深度，如下所示：

StackTraceElement[] trace = Thread.currentThread().getStackTrace();
if (trace.length > SOME_VALUE) {
  // trigger some diagnostic action, print a stack trace or have a breakpoint here
}

需要通过实验找到SOME_VALUE（足够高，不会在“良好”的情况并且足够低，不会无法到达）。当然，这会减慢您的代码速度，并且只能用于调试问题。

更新：我似乎忽略了问题发生在Pattern中，这使事情变得复杂。但是，您可以在堆栈跟踪中的 Pattern 方法之一处使用条件方法断点，条件如下（实际值可能需要调整）：

Thread.currentThread().getStackTrace().length > 300

这样您就可以在当您到达断点时，堆栈底部。

Answer 3

如果堆栈不足，请考虑创建一个具有足够堆栈的专用线程，特别是用于运行请求。下面的示例代码。

package t1;

import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.regex.Pattern;

public class RegExpRunner {
    ExecutorService svc;    
    public RegExpRunner(long stackSize){
        init(stackSize);

    }


    void init(long stackSize){
        final SynchronousQueue<Runnable> queue = new SynchronousQueue<Runnable>();

        svc = new ThreadPoolExecutor(1, 2, 60, TimeUnit.SECONDS,  queue, createThreadFactory(stackSize), new RejectedExecutionHandler(){//wait if there is a concurrent compile and no available threads
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                try{
                    queue.put(r);
                }catch(InterruptedException _ie){
                    Thread.currentThread().interrupt();
                    throw new IllegalStateException(_ie);
                }
            }                   
        });
    }

    private ThreadFactory createThreadFactory(final long stackSize) {       
        return new ThreadFactory(){
            final ThreadGroup g = Thread.currentThread().getThreadGroup();
            private final AtomicLong counter= new AtomicLong();
            {
                //take care of contextClassLoader and AccessControlContext              
            }

            @Override
            public Thread newThread(Runnable r) {               
                Thread t = new Thread(g, r, composeName(r), stackSize);
                return t;
            }

            protected String composeName(Runnable r) {
                return String.format("Regexp dedicated compiler: %d @ %tF %<tT ", counter.incrementAndGet(), System.currentTimeMillis());
            }   
        };
    };

    public Pattern compile(final String regex){//add flags if you need 'em
        Callable<Pattern> c = new Callable<Pattern>(){
            @Override
            public Pattern call() throws Exception {
                return Pattern.compile(regex);
            }           
        };

        try{
            Pattern p = svc.submit(c).get();
            return p;
        }catch(InterruptedException _ie){
            Thread.currentThread().interrupt();
            throw new IllegalStateException(_ie);
        } catch(CancellationException _cancel){
            throw new AssertionError(_cancel);//shan't happen
        } catch(ExecutionException _exec){
            Throwable t = _exec.getCause();
            if (t instanceof RuntimeException) throw (RuntimeException) t;
            if (t instanceof Error) throw (Error) t;
            throw new IllegalStateException(t==null?_exec:t);
        }


    }
}

Answer 4

我会尝试插入一些东西来装饰堆栈跟踪输出，类似于 ExceptionUtils 将重复调用分组到同一类或包裹。

Answer 5

当我重现问题时，我会触发手动线程转储。最有可能的是，stackoverflow 仅在一段时间后才会抛出。因此，我们可以快速触发 jvm 上的线程转储，这将通过在堆栈溢出之前打印有问题线程的整个堆栈来为我们提供有关调用者的详细信息。