Over a million developers have joined DZone.

Can try/finally Prevent a StackOverflowError?

· Java Zone

Navigate the Maze of the End-User Experience and pick up this APM Essential guide, brought to you in partnership with CA Technologies

 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.

Thrive in the application economy with an APM model that is strategic. Be E.P.I.C. with CA APM.  Brought to you in partnership with CA Technologies.

Topics:

Published at DZone with permission of Peter Lawrey, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

The best of DZone straight to your inbox.

SEE AN EXAMPLE
Please provide a valid email address.

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.
Subscribe

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

{{ parent.tldr }}

{{ parent.urlSource.name }}