@Async for async methods in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to enable asynchronous execution of the method.

Spring Boot

@[1]
public void sendEmail() {
    // email sending logic
}

Drag options to blanks, or click blank then click option'

ATransactional

BAsync

CService

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Transactional instead of @Async

Forgetting to enable async support in configuration

The @Async annotation marks the method to run asynchronously in Spring Boot.

2fill in blank

medium

Complete the code to enable async support in the Spring Boot application.

Spring Boot

@Configuration
@Enable[1]
public class AsyncConfig {
}

Drag options to blanks, or click blank then click option'

AScheduling

BTransactionManagement

CCaching

DAsync

Attempts:

3 left

💡 Hint

Common Mistakes

Using @EnableScheduling instead of @EnableAsync

Not adding this annotation causes @Async to be ignored

The @EnableAsync annotation enables Spring's asynchronous method execution capability.

3fill in blank

hard

Fix the error in the async method declaration to return a Future result.

Spring Boot

@Async
public [1]<String> processData() {
    // processing logic
    return new AsyncResult<>("done");
}

Drag options to blanks, or click blank then click option'

AFuture

BCompletableFuture

CListenableFuture

DCallable

Attempts:

3 left

💡 Hint

Common Mistakes

Returning void when a Future is expected

Using incompatible return types like Callable

The method should return java.util.concurrent.Future to work with @Async and AsyncResult.

4fill in blank

hard

Fill both blanks to correctly configure a custom executor for async methods.

Spring Boot

@Bean
public Executor [1]() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(25);
    executor.initialize();
    return [2];
}

Drag options to blanks, or click blank then click option'

AtaskExecutor

Bexecutor

CasyncExecutor

DthreadPool

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a different variable name than created

Using inconsistent method names

The method name is taskExecutor and the returned object is executor.

5fill in blank

hard

Fill all three blanks to correctly annotate and configure async method with custom executor.

Spring Boot

@Async([1])
public void runTask() {
    // task logic
}

@Bean
public Executor [2]() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(3);
    executor.setMaxPoolSize(6);
    executor.setQueueCapacity(10);
    executor.initialize();
    return [3];
}

Drag options to blanks, or click blank then click option'

A"taskExecutor"

BtaskExecutor

Cexecutor

DcustomExecutor

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names instead of string in @Async

Mismatching bean method name and returned variable

The @Async annotation references the executor bean name as a string, the bean method is named taskExecutor, and the returned variable is executor.

Practice

1.

What is the main purpose of using @Async in a Spring Boot application?

easy

A. To secure methods with authentication

B. To make methods run faster by optimizing CPU usage

C. To automatically retry failed methods

D. To run methods in the background without blocking the main thread

Solution

1. Step 1: Understand what @Async does

   @Async allows methods to run in a separate thread, so they don't block the main thread.

2. Step 2: Identify the main benefit

   This helps keep the app responsive by running long tasks in the background.

3. Final Answer:

   To run methods in the background without blocking the main thread -> Option D

4. Quick Check:

   Background execution = To run methods in the background without blocking the main thread [OK]

Hint: Async means background task, not faster or secure [OK]

Common Mistakes:

• Thinking @Async speeds up method execution
• Confusing @Async with security annotations
• Assuming @Async retries failed methods automatically

2.

Which annotation must be added to a Spring Boot configuration class to enable @Async support?

easy

A. @EnableAsync

B. @EnableScheduling

C. @AsyncSupport

D. @EnableAsyncSupport

Solution

1. Step 1: Recall the enabling annotation for async

   Spring Boot requires @EnableAsync on a configuration class to activate async processing.

2. Step 2: Confirm the exact annotation name

   The correct annotation is @EnableAsync, not any other variant.

3. Final Answer:

   @EnableAsync -> Option A

4. Quick Check:

   Enable async = @EnableAsync [OK]

Hint: Enable async with @EnableAsync, not similar names [OK]

Common Mistakes:

• Using @EnableScheduling instead of @EnableAsync
• Guessing annotation names without checking docs
• Confusing @Async with enabling annotations

3.

Consider this Spring Boot method annotated with @Async:

  @Async
  public CompletableFuture<String> fetchData() {
    return CompletableFuture.completedFuture("Done");
  }

What will be the output if you call fetchData().get()?

medium

A. It blocks until the async task completes and returns "Done"

B. It throws a NullPointerException

C. It returns "Done" immediately

D. It returns null because async methods don't return values

Solution

1. Step 1: Understand CompletableFuture with @Async

   The method returns a CompletableFuture that completes immediately with "Done".

2. Step 2: Calling get() on CompletableFuture

   Calling get() blocks the caller until the async task finishes and then returns the result.

3. Final Answer:

   It blocks until the async task completes and returns "Done" -> Option A

4. Quick Check:

   CompletableFuture.get() blocks and returns result [OK]

Hint: CompletableFuture.get() waits for async result [OK]

Common Mistakes:

• Assuming async methods return immediately without blocking on get()
• Thinking async methods can't return values
• Confusing exceptions with null returns

4.

Given this Spring Boot service method:

  @Async
  public void process() {
    System.out.println("Start");
    throw new RuntimeException("Error");
  }

What happens when process() is called?

medium

A. The exception is thrown on the caller thread immediately

B. The exception is logged but does not affect the caller thread

C. The method runs synchronously and throws the exception normally

D. The exception is ignored silently

Solution

1. Step 1: Understand exception handling in @Async methods

   Exceptions in async methods run in a separate thread and do not propagate to the caller.

2. Step 2: What happens to the exception?

   The exception is logged by Spring but does not crash or throw on the caller thread.

3. Final Answer:

   The exception is logged but does not affect the caller thread -> Option B

4. Quick Check:

   Async exceptions logged, caller unaffected [OK]

Hint: Async exceptions don't throw on caller thread [OK]

Common Mistakes:

• Expecting exceptions to propagate to caller immediately
• Thinking async methods run synchronously
• Assuming exceptions are ignored silently

5.

You want to run two independent tasks asynchronously and wait concurrently for both to finish before proceeding. Which approach using @Async and CompletableFuture is correct?

  @Async
  public CompletableFuture<String> taskOne() { ... }

  @Async
  public CompletableFuture<String> taskTwo() { ... }

  public void runTasks() throws Exception {
    CompletableFuture<String> future1 = taskOne();
    CompletableFuture<String> future2 = taskTwo();
    // What to do here?
  }

hard

A. Just call taskOne() and taskTwo() without waiting

B. Call future1.get() and future2.get() sequentially to wait

C. Use CompletableFuture.allOf(future1, future2).join() to wait both

D. Call future1.complete() and future2.complete() manually

Solution

1. Step 1: Understand waiting for multiple async tasks

   Calling get() sequentially works but is inefficient and blocks one after another.

2. Step 2: Use CompletableFuture.allOf for parallel waiting

   CompletableFuture.allOf(future1, future2).join() waits for both tasks to complete concurrently.

3. Final Answer:

   Use CompletableFuture.allOf(future1, future2).join() to wait both -> Option C

4. Quick Check:

   Wait all async tasks with allOf().join() [OK]

Hint: Use allOf().join() to wait multiple async tasks together [OK]

Common Mistakes:

• Calling get() sequentially causing unnecessary blocking
• Not waiting at all and proceeding too early
• Trying to manually complete futures which is incorrect