Java - Save/restore call stack

Question

Is it possible to save the state of the call stack during execution and later restore the stack to that state, restarting at the top-most method call?

Answer 1

I strongly suggest to change your paradigm. Instead of manipulating the call stack (and very probably corrupting your JVM), think about incorporating the "call stack" somehow in your algorithm.

You may use the Strategy/Command/Undo design pattern and store the objects to your own logical stack, over which you have full control.

There is a related question Way to go from recursion to iteration with a lot of good answers.

Answer 2

You can restart from a specific call stack with normal program flow control, instead of messing directly with call stacks. One way is with exceptions:

Result findResult() {
    while (true) {
        Data data = getData();
        try {
            return processData(data);
        } catch (OutOfDateException e) {
            /* fall through */
        }
    }
}

Result processData(Data data) throws OutOfDateException {
    /* ... */
    processData2(otherData)
    /* ... */
}

IntermediateResult processData2(OtherData otherData) throws OutOfDateException {
    /* ... */
    if (myDataWasTooOld())
        throw new OutOfDateException();
    /* ... */
}

In the example, if processData2() throws the exception, the same call stack (processData2() called from processData()) is recreated with a new value for data.

Answer 3

I think you're looking for something Continuations based... Java Flow is an old project, but I think it does exactly what you ask - saves stack frames as a Continuation object, using bytecode "magic" - that is, some extra code is weaved into your code to allow for stack frames to be saved into an object.

http://commons.apache.org/sandbox/commons-javaflow/tutorial.html

Answer 4

Saving the current call stack is quite simple. The Thread class has some stack trace oriented functions. Most likely this is what you are looking for -

StackTraceElement[] stack = Thread.currentThread().getStackTrace();

And now you have saved your stack trace, to be used later however you will. Im not sure what you mean by restore the stack trace though.

Answer 5

It is definitely possible to watch the stack trace. I have done this before after doing too much shell scripting and getting a response for every line of code. What I did was to create a listener thread that is a child of the main thread.

Something like this:

public class Debugger implements Serializable {
    private static final long serialVersionUID = 1L;

    private Thread parent;
    private String packageName;
    private File outputFile;
    private boolean alive;

    public Debugger(Thread parent, String packageName, File outputFile) {
        this.parent = parent;
        this.packageName = packageName;
        this.outputFile = outputFile;
        alive = true;
    }

    public void run() throws FileNotFoundException {
        PrintStream ps = new PrintStream(outputFile);
        alive = true;
        String lastClassName = "";
        while (parent.isAlive() && alive) {
            for (StackTraceElement ste : parent.getStackTrace()) {
                if (ste.getClassName().startsWith(packageName)) {
                    if (!ste.getClassName().equals(lastClassName)) {
                        ps.println(ste.toString());
                        lastClassName = ste.getClassName();
                    }
                    break;
                }
            }
        }
        ps.close();
    }

    public void kill() {
        alive = false;
    }
}

If you create this object at the beginning of the code you would like to debug, it will write to your file every new method in your package prefix/substring that is called. Then just call kill() at the code you want to watch for the stack trace. There is a chance that it will miss methods if your main thread/code runs faster than this thread, but it will more than likely catch everything.

You could include a timestamp (new Date()) there to see how long your method calls take to return as well.

In order to get what you wanted, you could save these method calls within the stack trace and use reflection to invoke the methods again later. However, I do think that would be a bad practice.