@EnableAsync annotation in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to enable asynchronous processing in a Spring Boot application.

Spring Boot

@Configuration
@[1]
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        return Executors.newCachedThreadPool();
    }
}

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

AEnableScheduling

BAsync

CEnableAsync

DAsyncConfigurer

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Async instead of @EnableAsync on configuration class

Confusing with @EnableScheduling

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

2fill in blank

medium

Complete the method annotation to mark it for asynchronous execution.

Spring Boot

public class MyService {
    @[1]
    public void process() {
        // long running task
    }
}

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

AAsync

BEnableAsync

CScheduled

DTransactional

Attempts:

3 left

💡 Hint

Common Mistakes

Using @EnableAsync on methods instead of @Async

Confusing with @Scheduled for async tasks

The @Async annotation marks a method to run asynchronously.

3fill in blank

hard

Fix the error in the configuration class to properly enable async support.

Spring Boot

@[1]
@Configuration
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        return Executors.newCachedThreadPool();
    }
}

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

ABean

BAsync

CConfiguration

DEnableAsync

Attempts:

3 left

💡 Hint

Common Mistakes

Placing @EnableAsync on a method instead of the class

Omitting @EnableAsync entirely

The @EnableAsync annotation must be placed on the configuration class to enable async processing.

4fill in blank

hard

Fill both blanks to create a configuration class that enables async and defines a thread pool executor.

Spring Boot

@[1]
@[2]
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        return Executors.newFixedThreadPool(5);
    }
}

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

AEnableAsync

BComponent

CConfiguration

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Configuration

Forgetting @EnableAsync annotation

The class must be annotated with @Configuration to define beans and @EnableAsync to activate async support.

5fill in blank

hard

Fill all three blanks to define an async method with a custom executor and enable async support.

Spring Boot

@[1]
@[2]
public class AsyncConfig {
    @Bean(name = "customExecutor")
    public Executor taskExecutor() {
        return Executors.newSingleThreadExecutor();
    }
}

public class MyService {
    @[3]("customExecutor")
    public void runTask() {
        // async task
    }
}

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

AEnableAsync

BConfiguration

CAsync

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting @EnableAsync on configuration class

Not specifying executor name in @Async annotation

The configuration class needs @Configuration and @EnableAsync. The async method uses @Async with the custom executor name.

Practice

1. What is the main purpose of the @EnableAsync annotation in a Spring Boot application?

easy

A. To enable automatic database transactions

B. To enable REST API endpoint scanning

C. To enable running methods asynchronously in the background

D. To enable security features like authentication

Solution

1. Step 1: Understand what @EnableAsync does

   This annotation activates Spring's ability to run methods asynchronously, meaning in the background without blocking the main thread.

2. Step 2: Compare with other options

   Other options relate to transactions, REST scanning, or security, which are unrelated to @EnableAsync.

3. Final Answer:

   To enable running methods asynchronously in the background -> Option C

4. Quick Check:

   @EnableAsync = run methods asynchronously [OK]

Hint: Remember: Enable async means run tasks in background [OK]

Common Mistakes:

• Confusing @EnableAsync with transaction management
• Thinking it enables REST endpoints
• Assuming it controls security features

2. Which of the following is the correct way to enable asynchronous method execution in a Spring Boot application?

easy

A. Add @Async on configuration class and @EnableAsync on methods

B. Add @Async on the main application class only

C. Add @EnableAsync on every method you want async

D. Add @EnableAsync on a configuration class and @Async on methods

Solution

1. Step 1: Identify correct annotation placement

   @EnableAsync must be on a configuration or main class to activate async support globally.

2. Step 2: Mark methods with @Async

   Methods that should run asynchronously need the @Async annotation.

3. Final Answer:

   Add @EnableAsync on a configuration class and @Async on methods -> Option D

4. Quick Check:

   Enable async globally + mark methods async = Add @EnableAsync on a configuration class and @Async on methods [OK]

Hint: Enable async on config class, async on methods [OK]

Common Mistakes:

• Putting @Async on the main class only
• Using @EnableAsync on methods instead of config
• Mixing up @Async and @EnableAsync roles

3. Given the code below, what will be the output when mainMethod() is called?

@EnableAsync
@Configuration
public class AppConfig {}

@Service
public class MyService {
  @Async
  public void asyncMethod() {
    System.out.println("Async task started");
  }

  public void mainMethod() {
    System.out.println("Main method start");
    asyncMethod();
    System.out.println("Main method end");
  }
}

medium

A. Main method start
Main method end
Async task started

B. Main method start
Async task started
Main method end

C. Async task started
Main method start
Main method end

D. Main method start
Main method end

Solution

1. Step 1: Understand async method behavior

   The @Async method runs asynchronously only when called from a different Spring-managed bean proxy. Calling asyncMethod() directly within the same class does NOT run asynchronously, so it executes synchronously.

2. Step 2: Trace output order

   All print statements execute in order: "Main method start", "Async task started", then "Main method end".

3. Final Answer:

   Main method start Async task started Main method end -> Option B

4. Quick Check:

   Direct self-invocation bypasses async proxy, so method runs synchronously [OK]

Hint: Async methods called within same class run synchronously [OK]

Common Mistakes:

• Assuming async prints immediately in order
• Thinking async blocks main thread
• Ignoring that async runs in background thread only when called via proxy

4. Consider this Spring Boot setup:

@Configuration
public class AsyncConfig {
  @Async
  public void runAsync() {
    System.out.println("Running async");
  }
}

What is the main problem with this code?

medium

A. Missing @EnableAsync annotation to activate async support

B. Methods annotated with @Async must return a value

C. @Async cannot be used inside @Configuration classes

D. The method must be static to run asynchronously

Solution

1. Step 1: Check if async support is enabled

   Without @EnableAsync on a configuration or main class, Spring will not run @Async methods asynchronously.

2. Step 2: Validate other options

   @Async methods can be void, can be in any Spring bean, and do not need to be static.

3. Final Answer:

   Missing @EnableAsync annotation to activate async support -> Option A

4. Quick Check:

   Enable async missing = async won't run [OK]

Hint: Always add @EnableAsync to activate async methods [OK]

Common Mistakes:

• Thinking @Async needs return value
• Believing @Async can't be in config classes
• Assuming method must be static

5. You want to run multiple slow tasks in parallel in a Spring Boot app. Which setup correctly uses @EnableAsync and @Async to achieve this?

@Configuration
@EnableAsync
public class AsyncConfig {}

@Service
public class TaskService {
  @Async
  public CompletableFuture<String> slowTask(String name) {
    Thread.sleep(2000);
    return CompletableFuture.completedFuture(name + " done");
  }
}

// In some controller or service
public void runTasks() {
  CompletableFuture<String> t1 = taskService.slowTask("Task1");
  CompletableFuture<String> t2 = taskService.slowTask("Task2");
  CompletableFuture.allOf(t1, t2).join();
  System.out.println("All tasks completed");
}

hard

A. This setup runs slowTask methods in parallel without blocking main thread

B. This setup runs slowTask methods sequentially blocking main thread

C. Missing @Async on slowTask method, so runs sequentially

D. Missing @EnableAsync, so async calls run synchronously

Solution

1. Step 1: Check annotations and method return type

   @EnableAsync is present to enable async support, and @Async marks slowTask to run asynchronously returning CompletableFuture.

2. Step 2: Understand method calls and joining

   Calling slowTask twice starts both tasks in parallel threads. CompletableFuture.allOf(...).join() waits for both to finish without blocking main thread execution during tasks.

3. Final Answer:

   This setup runs slowTask methods in parallel without blocking main thread -> Option A

4. Quick Check:

   EnableAsync + Async + CompletableFuture = parallel tasks [OK]

Hint: Use @EnableAsync + @Async + CompletableFuture for parallel tasks [OK]

Common Mistakes:

• Forgetting @EnableAsync disables async behavior
• Not returning CompletableFuture causes sync execution
• Calling async methods without waiting causes premature exit