Comment obtenir la pleine pile de StackOverflowError

autant que je sache, il n'est pas possible d'obtenir la trace complète de la pile (cependant, je ne sais pas vraiment pourquoi).

cependant, ce que vous pouvez faire pour retrouver le problème, c'est de vérifier manuellement la profondeur de la pile dans votre code affecté comme ceci:

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 devrait être trouvé par expérimentation (assez haut pour ne pas être déclenché dans les "bonnes" situations et assez bas pour ne pas être inaccessible). Bien sûr, cela ralentirait votre code et ne devrait être utilisé que pour déboguer le problème.

mise à Jour: il me semble avoir raté le problème se produit dans Pattern, ce qui complique les choses. Cependant, vous pouvez utiliser un point de rupture de méthode conditionnelle à l'un des Pattern méthodes dans la trace de la pile avec une condition comme ceci (la valeur réelle pourriez avoir besoin de réglages):

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

de Cette façon, vous pouvez trouver votre propre code au bas de la pile quand vous frappez le point d'arrêt.

si vous êtes à court de stack, pensez à créer un thread dédié avec suffisamment de stack pour lancer la requête. Exemple de code ci-dessous.

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


    }
}

j'essaierais de brancher quelque chose pour décorer la sortie de trace stack similaire à ExceptionUtils grouper les appels répétés à la même classe ou au même paquet.

Je déclencherais un dump manuel de thread pendant que je reproduis le problème. Probablement le stackoverflow est levée qu'après un certain temps. Ainsi, nous pouvons rapidement déclencher un dump de Thread sur jvm qui nous donnera des détails sur l'appelant en imprimant la pile entière du thread problématique avant que sa pile soit survolée.