Course: Core Java Training
Topic: Using finally and Understanding Resource Cleanup
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy
In Java, exception handling allows programs to respond to errors that occur during execution. However, handling an exception is not always enough. A program may also need to release resources, close files, disconnect from a database, or clean up temporary objects before it finishes an operation.
Java provides the finally block to execute cleanup code after a try block and any matching catch block. For resources such as files, streams, and database connections, Java also provides try-with-resources, which automatically closes objects that implement the AutoCloseable interface.
These concepts help developers avoid resource leaks and create reliable, maintainable applications.
finally block.AutoCloseable interface.The finally block is a section of code associated with a try statement. It is commonly used for cleanup operations that should generally happen whether the try block completes successfully or an exception is thrown and handled.
For example, when a program opens a file and then encounters an error, it may still need to close the file. Placing the closing operation in a finally block helps ensure that the resource is released during normal exception-handling flow.
try {
// Code that may throw an exception
} catch (ExceptionType e) {
// Handle the exception
} finally {
// Cleanup code
}A try statement can have one or more catch blocks, a finally block, or both. A try statement must include at least one catch or finally block unless it is written as a try-with-resources statement.
public class FinallyExample {
public static void main(String[] args) {
try {
System.out.println("Inside try block");
} catch (Exception e) {
System.out.println("Exception handled");
} finally {
System.out.println("Finally block executed");
}
System.out.println("Program completed");
}
}Output:
Inside try block
Finally block executed
Program completedExplanation: No exception occurs, so the catch block is skipped. The finally block executes after the try block, and the program continues with the statement after the try-catch-finally structure.
The finally block generally executes even when an exception occurs and is handled by a catch block. This makes it useful for cleanup operations that should not be skipped during ordinary exception handling.
public class FinallyWithException {
public static void main(String[] args) {
try {
int result = 10 / 0;
System.out.println(result);
} catch (ArithmeticException e) {
System.out.println("Arithmetic exception handled");
} finally {
System.out.println("Cleanup operation completed");
}
System.out.println("Program continues");
}
}Output:
Arithmetic exception handled
Cleanup operation completed
Program continuesExplanation: Integer division by zero throws an ArithmeticException. The catch block handles it, the finally block executes, and the program continues.
Important: Finally is not guaranteed to run under every possible circumstance. Abrupt JVM termination, a process crash, or a machine failure may prevent it from executing. Do not rely on finally for cleanup that must survive such failures.
A finally block generally executes before a method completes a return from its try or catch block. However, placing another return statement inside finally can override the original return value or suppress an exception. This behavior should be avoided.
public class FinallyReturnExample {
static int getNumber() {
try {
return 10;
} finally {
System.out.println("Finally executes before return completes");
}
}
public static void main(String[] args) {
System.out.println(getNumber());
}
}Output:
Finally executes before return completes
10Explanation: The method prepares to return 10. The finally block executes before the method completes the return.
Best practice: Avoid return, break, or continue statements in finally when they could override or disrupt the control flow of the try or catch blocks.
Resource cleanup is the process of releasing resources after they are no longer needed. Some resources are managed by the Java runtime, while others represent external system resources that should be closed explicitly.
Common examples include:
AutoCloseable.When a program repeatedly opens files or database connections without closing them, it may exhaust the available resources. This problem is called a resource leak.
| Reason | Explanation |
|---|---|
| Prevents resource leaks | Closes resources that are no longer required. |
| Improves reliability | Reduces failures caused by exhausted system resources. |
| Supports data integrity | Allows buffered data to be flushed when the resource is properly closed. |
| Improves scalability | Prevents applications from holding unnecessary connections or file handles. |
| Simplifies maintenance | Makes resource ownership and cleanup easier to understand. |
Before try-with-resources was introduced in Java 7, developers commonly used finally blocks to close resources. This approach remains useful for certain cleanup tasks, but it requires careful handling because the resource might not have been initialized and the closing operation can itself throw an exception.
import java.io.FileInputStream;
import java.io.IOException;
public class FinallyResourceCleanup {
public static void main(String[] args) {
FileInputStream input = null;
try {
input = new FileInputStream("sample.txt");
int data = input.read();
System.out.println("First byte: " + data);
} catch (IOException e) {
System.out.println("File operation failed: " + e.getMessage());
} finally {
if (input != null) {
try {
input.close();
System.out.println("File stream closed");
} catch (IOException e) {
System.out.println("Unable to close stream: " + e.getMessage());
}
}
}
}
}Explanation:
null.Note: This example demonstrates traditional manual cleanup. For resources implementing AutoCloseable, try-with-resources is generally shorter and safer.
Try-with-resources is a Java feature introduced in Java 7 that automatically closes resources when execution leaves the try block. It reduces the need to write manual cleanup code.
A resource declared in a try-with-resources statement must implement the AutoCloseable interface or one of its subinterfaces, such as Closeable.
try (ResourceType resource = new ResourceType()) {
// Use the resource
} catch (Exception e) {
// Handle errors
}import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TryWithResourcesExample {
public static void main(String[] args) {
try (BufferedReader reader =
new BufferedReader(new FileReader("sample.txt"))) {
String line = reader.readLine();
System.out.println("First line: " + line);
} catch (IOException e) {
System.out.println("File operation failed: " + e.getMessage());
}
}
}Explanation:
Note: The file must exist and be accessible for the read operation to succeed.
| Feature | finally | try-with-resources |
|---|---|---|
| Purpose | Executes cleanup or other finalization logic. | Automatically closes declared resources. |
| Closing resources | Usually requires an explicit call to close(). |
Calls the resource's close() method automatically. |
| Code length | Can require null checks and nested exception handling. | Usually shorter and easier to maintain. |
| Resource requirements | Can perform cleanup for many kinds of objects and application state. | Works with resources implementing AutoCloseable. |
| Closing exceptions | Must be handled carefully to avoid masking an earlier exception. | Preserves a primary exception and records additional closing failures as suppressed exceptions when applicable. |
| Typical use | General cleanup tasks. | Files, streams, database resources, and other closeable objects. |
Best practice: Prefer try-with-resources for resources implementing AutoCloseable. Use finally for cleanup that is not automatically managed by try-with-resources.
AutoCloseable is an interface in the java.lang package. It defines a close() method that allows an object to release resources when it is no longer needed.
class MyResource implements AutoCloseable {
public void use() {
System.out.println("Resource is being used");
}
@Override
public void close() {
System.out.println("Resource is closed");
}
}
public class AutoCloseableExample {
public static void main(String[] args) {
try (MyResource resource = new MyResource()) {
resource.use();
}
}
}Output:
Resource is being used
Resource is closedExplanation: The custom class implements AutoCloseable and provides a close() method. Java automatically calls this method when execution leaves the try-with-resources statement.
A try-with-resources statement can declare multiple resources. Java initializes resources from left to right and attempts to close successfully initialized resources in reverse order.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class MultipleResourcesExample {
public static void main(String[] args) {
try (
BufferedReader reader =
new BufferedReader(new FileReader("input.txt"));
BufferedWriter writer =
new BufferedWriter(new FileWriter("output.txt"))
) {
String line;
while ((line = reader.readLine()) != null) {
writer.write(line);
writer.newLine();
}
System.out.println("File copied successfully.");
} catch (IOException e) {
System.out.println("File operation failed: " + e.getMessage());
}
}
}Explanation:
Important: This example assumes that the file paths are appropriate. The standard FileWriter constructor overwrites an existing output file by default.
Sometimes an exception occurs during the main operation and another exception occurs while the resource is being closed. In try-with-resources, the original exception is generally preserved as the primary exception, while the closing exception is attached as a suppressed exception.
class DemoResource implements AutoCloseable {
public void process() {
throw new IllegalStateException("Processing failed");
}
@Override
public void close() {
throw new IllegalStateException("Closing failed");
}
}
public class SuppressedExceptionExample {
public static void main(String[] args) {
try (DemoResource resource = new DemoResource()) {
resource.process();
} catch (Exception e) {
System.out.println("Primary: " + e.getMessage());
for (Throwable suppressed : e.getSuppressed()) {
System.out.println(
"Suppressed: " + suppressed.getMessage()
);
}
}
}
}Output:
Primary: Processing failed
Suppressed: Closing failedExplanation: The process() method throws the primary exception. The close() method also throws an exception, but try-with-resources preserves the processing failure and attaches the closing failure to it.
Opening a file or database connection without closing it can cause resource leaks. Prefer try-with-resources for objects that implement AutoCloseable.
When using traditional finally-based cleanup, a resource may not have been initialized successfully. Check whether the resource is null before calling its close() method.
If an exception occurs in the try block and another exception escapes from finally, the cleanup exception can replace the original exception. Use try-with-resources where appropriate or handle cleanup exceptions carefully.
Manually closing multiple resources can produce lengthy and error-prone code. Try-with-resources is generally easier to maintain for closeable resources.
Garbage collection manages Java memory, but it does not guarantee prompt release of external resources such as file handles or database connections. Close these resources explicitly or use automatic resource management.
Finally generally executes during normal Java control flow, but forced JVM termination, a process crash, or a machine failure can prevent it from running. Do not treat it as a guarantee against every possible failure.
AutoCloseable resources.close() method behaves.Task: Create a Java program that uses a custom resource implementing AutoCloseable and demonstrates automatic cleanup.
Requirements:
StudentFileResource that implements AutoCloseable.readData() that prints a message.close() method to print a cleanup message.Sample solution:
class StudentFileResource implements AutoCloseable {
public void readData() {
System.out.println("Reading student data");
}
@Override
public void close() {
System.out.println("Student resource released");
}
}
public class ResourceCleanupExercise {
public static void main(String[] args) {
try (StudentFileResource resource = new StudentFileResource()) {
resource.readData();
}
System.out.println("Program completed");
}
}Expected output:
Reading student data
Student resource released
Program completedPractice extension: Modify readData() so that it throws an exception. Run the program and observe whether the resource is still closed when the try-with-resources statement exits.
Answer: Finally is used for cleanup or finalization code that should generally execute when a try statement exits, whether normally or through exception handling.
Answer: No. It generally executes during ordinary control flow, but it may not run if the JVM terminates abruptly or the process or machine fails.
Answer: Yes. A try block can be followed directly by a finally block.
Answer: Resource cleanup releases resources that are no longer needed, such as file handles, streams, database connections, and sockets.
Answer: It is a Java feature that automatically closes declared resources when the try statement finishes.
Answer: Resources must implement AutoCloseable. The Closeable interface extends AutoCloseable.
Answer: The exception from the try block is generally preserved as the primary exception, while the closing exception is recorded as a suppressed exception.
Answer: Finally can execute general cleanup logic, while try-with-resources automatically closes resources implementing AutoCloseable.
Answer: A return statement in finally can override a return from try or catch and can suppress an exception.
Answer: No. Garbage collection manages Java memory, but external resources should be closed explicitly or through try-with-resources.
close() method used by try-with-resources.The finally block and resource cleanup are essential concepts in Java exception handling. Finally provides a place for cleanup code that should generally run when a try statement exits, while try-with-resources provides a safer and more concise way to close resources implementing AutoCloseable.
By understanding execution flow, closing resources correctly, handling cleanup exceptions, and following recommended practices, developers can create more reliable and maintainable Java applications.
Continue learning with the JustAcademy Core Java Training Course. You can also register for a course demo or visit the JustAcademy website for more information.
