Over a million developers have joined DZone.
Platinum Partner

Can try/finally Prevent a StackOverflowError?

· Java Zone

The Java Zone is brought to you in partnership with ZeroTurnaround. Check out this 8-step guide to see how you can increase your productivity by skipping slow application redeploys and by implementing application profiling, as you code!

 This post is taken from a popular answer to a question try-finally block prevents StackOverflowError

Question

Take a look at the following two methods:
public static void foo(){
try{
        foo();
}finally{
        foo();
}}

public static void bar(){
    bar();}

Running bar() clearly results in a StackOverflowError, but running foo() does not (the program just seems to run indefinitely). Why is that?

Answer

It doesn't run forever. Each stack overflow causes the code to move to the finally block. The problem is that it will take a really, really long time. The order of time is O(2^N) where N is the maximum stack depth.
Imagine the maximum depth is 5
foo() calls
    foo() calls
       foo() calls
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally calls
       foo() calls
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally calls
    foo() calls
       foo() calls
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally calls
       foo() calls
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()finally
           foo() calls
              foo() which fails to call foo()finally calls
              foo() which fails to call foo()
To work each level into the finally block take twice as long an the stack depth could be 10,000 or more. If you can make 10,000,000 calls per second, this will take 10^3003 seconds or longer than the age of the universe.

The Java Zone is brought to you in partnership with ZeroTurnaround. Discover how you can skip the build and redeploy process by using JRebel by ZeroTurnaround.

Topics:

Published at DZone with permission of Peter Lawrey , DZone MVB .

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}