Home / Questions / 161
Accepted
Perdomoff
Asked: 2020-12-02 14:07:34 +0800 CST 2020-12-02 14:07:34 +0800 CST

Is the finally block always executed in Java?

  • 772

I have a try/catch with a return inside. Will the finally block execute?

try {  
    something();  
    return success;  
}  
catch (Exception e) {   
    return failure;  
}  
finally {  
    System.out.println("No se si esto se va a imprimir.");
}

I know I can write this and see what happens (which is really what I'm going to do) but when I googled it, nothing came up, so I asked the question here.

This is a question translated from the original in English and adapted to the results it gives on my computer: Does finally always execute in Java? jonny five

java

4 Answers

  1. Best Answer

    finally will be called.

    The only times finally won't be executed are when:

    1. if you call System.exit() or
    2. if the jvm has a crash first(crashes)

    This answer is a translation of jodonnell 's original English

    Edited 2/12/15: Considering Does the finally block execute if the thread running the function is interrupted? by Subhrajyoti Majumder

    • 29

  2. A very simple question based on java principles, the finally block will always be called.

    try {
    //Declaraciones que pueden causar una excepción.
}
catch {
   //Manejo de excepción.
}
finally {
   //Declaraciones a ser ejecutadas
}

    As long as as it is commented, you finish the execution of the code or there are errors.

    More information: The Finally Block

    • 8

  3. NOT ALWAYS

    The Java language specification describes how the try-catch-finally and try-finally blocks work in section 14.20.2 .
    Nowhere does it specify that finally is always executed.
    But it does specify that for all cases where the try-catch-finally or try-finally block completes before the finally block must have been executed.

    Namely. If SIG is what will be executed after the try-catch-finally or try-finally block and FIN is what is inside finally, the JLS guarantees that FIN is always executed before SIG is executed .

    Why doesn't the JLS guarantee that the finally block is always executed after the try block? Because it is impossible. It is unlikely but possible that the virtual machine will be aborted (kill, crash, shut down computer) just after the try block is finished and before the finally block is executed. And there is nothing that can be done from the language specification to avoid this.

    • 7

  4. Inside a block try / catch finallyit always executes, as the Java documentation says :

    The finally block is always executed when the block exits try. This ensures that the block finallyis executed even if an unexpected exception is thrown. But ultimately, it's useful for more than just exception handling: it allows the programmer to prevent cleanup code from being accidentally sidetracked by a return, continuation, or interrupt. Putting cleanup code in a block finallyis always a good practice , even when exceptions are not expected.

    enter image description here

    Note: If the JVM exits while the try or catch code is executing, then the finally block cannot be executed . Likewise, if the thread executing the code is tryeither catch interrupted or killed, the finally block cannot execute even though the application as a whole continues .

    As of Java SE 7 it `finally` lost prominence

    Before Java SE 7 you could implement the use of finallyas a key tool to prevent resource leaks . When closing a file or retrieving resources, it was recommended to put the code in a block finallyto ensure that the resource would always be retrieved or closed.

    Since it finallyalways executes, regardless of whether the statement trycompletes normally or abruptly, it finallywas the only possible option to ensure that a resource would eventually be closed.

    We see this in the following example:

    //Otro uso de finally antes de Java SE 7
static String readFirstLineFromFileWithFinallyBlock(String path)
                                                     throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(path));
    try {
        return br.readLine();
    } finally {
        if (br != null) br.close();
    }
}

    Before Java 7 finallyit helped us to leave the ground clean of all open resources.

    As of Java 7 the try-with-resources Statement has been implemented.

    The statement try-with-resourcesis a statement trythat declares one or more resources. A resource is an object that must be closed after the program has finished . The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects that implement java.io.Closeable, can be used as a resource.

    The following example reads the first line from a file. Uses an instance of BufferedReaderto read data from the file. BufferedReaderis a resource that should be closed after the program ends:

    static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br =
                   new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

    In this example, the resource declared in the statement try-with-resourcesis a BufferedReader. The declaration statement appears in parentheses immediately after the keyword try. The class BufferedReader, in Java SE 7 and later, implements the interface java.lang.AutoCloseable. Since the instance BufferedReaderis declared in a statement try-with-resources, it will exit regardless of whether the try statement completes normally or abruptly (as a result of the method BufferedReader.readLinethrowing a IOException).

    • -1