Exception handling in async in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when an exception is thrown inside an @Async method without a custom AsyncUncaughtExceptionHandler?

Consider a Spring Boot service method annotated with @Async that throws a runtime exception. What is the default behavior if no custom AsyncUncaughtExceptionHandler is configured?

Spring Boot

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {
    @Async
    public void asyncMethod() {
        throw new RuntimeException("Error in async method");
    }
}

A The exception is silently ignored without any logging or notification.

B The exception is propagated back to the caller thread and must be caught there.

C The application crashes immediately due to the uncaught exception in the async thread.

D The exception is logged by Spring's SimpleAsyncUncaughtExceptionHandler and does not propagate to the caller thread.

💡 Hint

Think about how Spring handles exceptions in void async methods by default.

By default, Spring uses SimpleAsyncUncaughtExceptionHandler which logs exceptions thrown from @Async methods that return void. The exception does not propagate to the caller thread.

📝 Syntax

intermediate

Which method signature correctly allows exception handling for an async method returning a Future?

You want to handle exceptions thrown in an async method that returns a CompletableFuture<String>. Which method signature is correct to enable catching exceptions in the caller thread?

A

@Async
public CompletableFuture<String> asyncMethod() {
    return CompletableFuture.supplyAsync(() -> {
        if(true) throw new RuntimeException("Error");
        return "Done";
    });
}

B

@Async
public void asyncMethod() throws Exception {
    throw new RuntimeException("Error");
}

C

@Async
public CompletableFuture<String> asyncMethod() {
    throw new RuntimeException("Error");
}

D

@Async
public String asyncMethod() {
    throw new RuntimeException("Error");
}

💡 Hint

Think about how to return a Future that can carry exceptions asynchronously.

Returning a CompletableFuture allows exceptions to be captured and handled asynchronously by the caller. Throwing exceptions directly in the method body without wrapping them in a Future will not propagate exceptions properly.

🔧 Debug

advanced

Why does this custom AsyncUncaughtExceptionHandler not log exceptions as expected?

Given the following custom AsyncUncaughtExceptionHandler, exceptions thrown in async void methods are not logged. What is the likely cause?

Spring Boot

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Component
public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // Missing logging implementation
    }
}

A The method signature is incorrect and does not override the interface method.

B The @Component annotation is missing, so Spring does not detect the handler.

C The handler does not log or print the exception, so exceptions appear unlogged.

D The handler must extend SimpleAsyncUncaughtExceptionHandler to work properly.

💡 Hint

Check what the handler does inside the overridden method.

The handler method is empty and does not log or handle the exception, so exceptions are effectively ignored.

🧠 Conceptual

advanced

How can you globally configure a custom AsyncUncaughtExceptionHandler in Spring Boot?

Which approach correctly sets a global custom AsyncUncaughtExceptionHandler for all @Async methods in a Spring Boot application?

A Implement AsyncConfigurer in a @Configuration class and override getAsyncUncaughtExceptionHandler() to return your handler bean.

B Annotate your handler class with @AsyncUncaughtExceptionHandler and Spring auto-detects it.

C Register your handler as a @Bean of type AsyncUncaughtExceptionHandler in any @Configuration class.

D Add @ExceptionHandler annotation on your handler class to catch async exceptions globally.

💡 Hint

Think about how Spring Boot allows configuring async behavior globally.

Implementing AsyncConfigurer and overriding getAsyncUncaughtExceptionHandler() is the standard way to globally set a custom handler for async exceptions.

❓ state_output

expert

What is the output when an exception is thrown inside an async method returning CompletableFuture and handled with exceptionally()?

Consider this Spring Boot async method and caller code. What will be printed?

Spring Boot

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {
    @Async
    public CompletableFuture<String> asyncMethod() {
        return CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Async error");
        });
    }
}

// Caller code
AsyncService service = new AsyncService();
service.asyncMethod()
    .exceptionally(ex -> {
        System.out.println("Caught: " + ex.getMessage());
        return "Recovered";
    })
    .thenAccept(result -> System.out.println("Result: " + result));

A

Caught: java.lang.RuntimeException: Async error
Result: Recovered

B

Caught: Async error
Result: Recovered

C No output because exceptions in async are swallowed silently

D Result: Recovered

💡 Hint

Check how the exception message is accessed inside exceptionally().

The exceptionally block catches the RuntimeException. ex.getMessage() returns "Async error". So it prints "Caught: Async error" and then "Result: Recovered".