Try-With-Resources

The try-with-resources statement is an exception-handling mechanism in Java that automatically manages the lifecycle of resources. It ensures that any resource declared within its specification header is automatically closed when the try block terminates, regardless of whether the termination is normal or abrupt.

To be eligible for use in a try-with-resources statement, an object’s class must implement the java.lang.AutoCloseable interface or its sub-interface, java.io.Closeable.

Syntax

Resources are declared within parentheses immediately following the try keyword. Multiple resources can be declared, separated by semicolons.

try (ResourceType resource1 = new ResourceType();
     ResourceType resource2 = new ResourceType()) {
    
    // Operations utilizing resource1 and resource2

} catch (ExceptionType e) {
    // Exception handling
} finally {
    // Optional standard finally block
}

Java 9 Enhancement: If a resource variable is final or effectively final, it can be referenced directly within the try header without requiring a new local variable declaration.

ResourceType resource = new ResourceType(); // Must be effectively final

try (resource) { 
    // Operations utilizing the resource
}

Execution Mechanics

1. Initialization: Resources are instantiated and assigned in the exact order they are declared (left-to-right).
2. Scope: The scope of the variables declared in the try header is strictly limited to the try block. They are not accessible within the catch or finally blocks.
3. Closure Order: The close() methods of the instantiated resources are invoked in the reverse order of their creation. This prevents dependency conflicts (e.g., closing a wrapper stream before the underlying base stream).
4. Timing of Closure: The automatic invocation of close() occurs before any catch or finally blocks associated with the try statement are executed.

Exception Suppression

A critical feature of try-with-resources is its handling of concurrent exceptions during the closure phase.

In a traditional try-finally block, if an exception is thrown in the try block, and another exception is thrown in the finally block while closing the resource, the second exception masks the first, resulting in the loss of the primary exception.

try-with-resources resolves this using exception suppression:

• If an exception is thrown within the try block, and a subsequent exception is thrown during the automatic close() invocation, the exception from the try block takes precedence.
• The exception thrown by the close() method is suppressed and attached to the primary exception.
• The suppressed exception(s) can be retrieved programmatically by calling Throwable.getSuppressed() on the caught primary exception.

try (CustomResource r = new CustomResource()) {
    throw new RuntimeException("Primary Exception");
} catch (Exception e) {
    // e is "Primary Exception"
    // If r.close() also threw an exception, it is stored in e.getSuppressed()
    Throwable[] suppressed = e.getSuppressed();
}

Master Java with Deep Grasping Methodology!

Learn More