Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Can try/finally Prevent a StackOverflowError?

DZone's Guide to

Can try/finally Prevent a StackOverflowError?

· Java Zone ·
Free Resource

Download Microservices for Java Developers: A hands-on introduction to frameworks and containers. Brought to you in partnership with Red Hat.

 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.

Download Building Reactive Microservices in Java: Asynchronous and Event-Based Application Design. Brought to you in partnership with Red Hat

Topics:

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

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

{{ parent.tldr }}

{{ parent.urlSource.name }}