Exception Propagation & Stack Unwinding

#What is Exception Propagation?

Exception propagation is the process by which an exception travels from the method where it occurs to its caller until it is handled.

If a method does not handle an exception, the JVM passes it to the calling method. This continues until:

• A matching catch block is found, or
• The exception reaches the JVM, causing program termination.

#Understanding the Call Stack

Whenever a method is called, the JVM creates a stack frame.

public static void main(String[] args) {
    method1();
}

#What is Stack Unwinding?

When an exception occurs, the JVM starts removing stack frames one by one while searching for a matching catch block. This process is called stack unwinding.

Suppose the stack is main() → method1() → method2() → method3() and the exception occurs in method3():

#Basic Example

public class Demo {

    static void method3() {
        int x = 10 / 0;
    }

    static void method2() {
        method3();
    }

    static void method1() {
        method2();
    }

    public static void main(String[] args) {
        try {
            method1();
        } catch (ArithmeticException e) {
            System.out.println("Handled");
        }
    }
}

Handled

If Nobody Handles the Exception

public static void main(String[] args) {
    method1();
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Demo.method3(Demo.java:4)
    at Demo.method2(Demo.java:8)
    at Demo.method1(Demo.java:12)
    at Demo.main(Demo.java:16)

The exception reaches the JVM, which prints the stack trace and terminates the thread.

Stack Trace Explained

Read it from top to bottom. The first stack frame is where the exception actually occurred; the remaining frames show how execution reached that point.

#Checked Exception Propagation

static void method3() throws IOException {
    throw new IOException();
}

static void method2() throws IOException {
    method3();
}

static void method1() throws IOException {
    method2();
}

Main:

public static void main(String[] args) {
    try {
        method1();
    } catch (IOException e) {
        System.out.println("Handled");
    }
}

#Runtime Exception Propagation

static void method3() {
    throw new RuntimeException();
}

No throws declaration is required — propagation still happens (method3 → method2 → method1 → main). Runtime exceptions propagate automatically.

#Propagation Stops at the First Matching Catch

static void method2() {
    try {
        method3();
    } catch (ArithmeticException e) {
        System.out.println("Handled in method2");
    }
}

Nested Propagation

try {
    method1();
} catch (IOException e) {
}

With method1() → method2() → method3() and an IOException in method3, the exception travels method3 → method2 → method1 → main → catch. Each method gets a chance to handle or propagate it.

#Propagation vs Handling

// Propagation
void read() throws IOException

// Handling
try {
    read();
} catch (IOException e) {
}

#Spring Boot Layered Architecture

Suppose a repository call fails with a database exception:

Wrapping During Propagation

Repository (plain JDBC):

throw new SQLException("Database Down");

Service:

catch (SQLException e) {
    throw new DatabaseException("Unable to save user", e);
}

Controller:

@ExceptionHandler(DatabaseException.class)

#Stack Unwinding Internals

Suppose main() → A() → B() → C() and the exception occurs in C():

finally During Propagation

try {
    method3();
} finally {
    System.out.println("Cleanup");
}