Peter is a DZone MVB and is not an employee of DZone and has posted 157 posts at DZone. You can read more from them at their website. View Full User Profile

Can try/finally Prevent a StackOverflowError?

11.24.2012
| 2330 views |
  • submit to reddit

 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.
Published at DZone with permission of Peter Lawrey, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)

Tags: