詳解 Spring Boot 中的 @Async 註解-Java-CodeUp Hub

@Async註解是Spring Boot提供的用於支援非同步方法執行的功能。透過@Async，Spring允許開發者在不阻塞主執行緒的情況下執行非同步任務，提高應用程式的響應能力和吞吐量。本文將詳細介紹@Async註解的使用、工作原理、配置方法、最佳實踐及常見失效場景。

1. `@Async`註解概述

@Async註解使得一個方法可以非同步執行，即該方法將在後臺執行緒中執行，而不會阻塞呼叫它的執行緒。這對於需要長時間執行的任務（如I/O操作、網路請求等）尤其有用。

2. 啟用非同步處理

在使用@Async之前，需要在Spring Boot應用中啟用非同步處理。這可以透過在配置類中使用@EnableAsync註解來完成。

示例程式碼：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AppConfig {
    // 配置類，啟用非同步處理
}

3. 使用`@Async`註解

@Async註解可以標記在任何@Component、@Service或@Repository等Spring管理的bean中的方法。標記為@Async的方法會在後臺執行緒中執行，而呼叫它的執行緒會立即返回。

3.1 基本示例

服務類：

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

@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        System.out.println("Executing asyncMethod in thread: " + Thread.currentThread().getName());
    }
}

呼叫類：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CallerComponent {

    @Autowired
    private AsyncService asyncService;

    public void callAsyncMethod() {
        asyncService.asyncMethod();
        System.out.println("Called asyncMethod in thread: " + Thread.currentThread().getName());
    }
}

主應用程式：

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class AsyncApplication {

    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }

    @Bean
    public CommandLineRunner run(CallerComponent callerComponent) {
        return args -> {
            callerComponent.callAsyncMethod();
        };
    }
}

在這個示例中，asyncMethod()方法會在一個獨立的執行緒中執行，callAsyncMethod()方法會立即返回，而不會阻塞主執行緒。

4. 返回值

@Async方法通常返回Future、CompletableFuture或ListenableFuture，允許呼叫者在將來某個時間點獲取結果。

4.1 使用`Future`

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

import java.util.concurrent.Future;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {

    @Async
    public Future<String> asyncMethodWithFuture() {
        try {
            Thread.sleep(2000); // 模擬長時間執行的任務
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return CompletableFuture.completedFuture("Result from asyncMethodWithFuture");
    }
}

呼叫類：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.Future;

@Component
public class CallerComponent {

    @Autowired
    private AsyncService asyncService;

    public void callAsyncMethodWithFuture() throws Exception {
        Future<String> future = asyncService.asyncMethodWithFuture();
        System.out.println("Waiting for asyncMethodWithFuture result...");
        String result = future.get(); // 阻塞直到結果返回
        System.out.println("Result: " + result);
    }
}

4.2 使用`CompletableFuture`

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

import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncMethodWithCompletableFuture() {
        try {
            Thread.sleep(2000); // 模擬長時間執行的任務
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return CompletableFuture.completedFuture("Result from asyncMethodWithCompletableFuture");
    }
}

呼叫類：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component
public class CallerComponent {

    @Autowired
    private AsyncService asyncService;

    public void callAsyncMethodWithCompletableFuture() {
        CompletableFuture<String> future = asyncService.asyncMethodWithCompletableFuture();
        future.thenAccept(result -> {
            System.out.println("Result: " + result);
        });
    }
}

5. 執行緒池配置

預設情況下，Spring使用一個簡單的執行緒池來處理非同步任務，但可以自定義執行緒池以滿足特定需求。使用@Async時，可以透過配置執行緒池來調整效能。

配置類：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
public class AppConfig {

    @Bean(name = "taskExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

在服務類中，可以透過@Async("taskExecutor")指定自定義的執行緒池。

服務類：

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

@Service
public class AsyncService {

    @Async("taskExecutor")
    public void asyncMethodWithCustomExecutor() {
        System.out.println("Executing asyncMethodWithCustomExecutor in thread: " + Thread.currentThread().getName());
    }
}

6. 異常處理

在非同步方法中丟擲的異常不會被直接捕獲。可以使用CompletableFuture的exceptionally方法來處理非同步方法中的異常。

示例程式碼：

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

import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncMethodWithException() {
        try {
            throw new RuntimeException("Something went wrong");
        } catch (Exception e) {
            return CompletableFuture.failedFuture(e);
        }
    }
}

呼叫類：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component
public class CallerComponent {

    @Autowired
    private AsyncService asyncService;

    public void callAsyncMethodWithException() {
        CompletableFuture<String> future = asyncService.asyncMethodWithException();
        future.exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return null;
        }).thenAccept(result -> {
            if (result != null) {
                System.out.println("Result: " + result);
            }
        });
    }
}

7. 常見失效場景

雖然@Async提供了強大的非同步處理功能，但在一些情況下，@Async可能會失效或表現不如預期。以下是一些常見的失效場景：

7.1 非同步方法呼叫自身

當一個@Async方法呼叫自身時，它不會在非同步執行緒中執行，因為呼叫是從同一物件的上下文中發生的。Spring AOP代理機制僅對從外部呼叫的@Async方法有效。

示例程式碼：

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

@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        System.out.println("Executing asyncMethod in thread: " + Thread.currentThread().getName());
        // 錯誤的非同步呼叫
        this.asyncMethod(); // 會在當前執行緒中執行
    }
}

解決方法： 使用其他bean或透過@Autowired注入AsyncService來呼叫非同步方法。

7.2 非public方法

@Async註解要求被註解的方法是public的。Spring的AOP代理機制只會對public方法生效，非public方法不會被代理。

示例程式碼：

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

@Service
public class AsyncService {

    @Async
    private void asyncMethod() { // 錯誤，非public方法
        System.out.println("Executing asyncMethod in thread: " + Thread.currentThread().getName());
    }
}

解決方法： 確保被註解的方法是public的。

7.3 同一類中呼叫

當從同一類中的方法呼叫另一個@Async方法時，@Async註解不會生效，因為呼叫是在同一個bean例項中進行的，不會透過代理處理。

示例程式碼：

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

@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        System.out.println("Executing asyncMethod in thread: " + Thread.currentThread().getName());
    }

    public void callAsyncMethod() {
        asyncMethod(); // 不會非同步執行
    }
}

解決方法： 從外部呼叫非同步方法，確保呼叫發生在不同的bean例項中。

7.4 不支援的返回型別

@Async註解不支援void返回型別以外的返回型別。儘管CompletableFuture等可以返回非同步結果，但直接返回void的非同步方法不會正確處理返回結果。

示例程式碼：

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

@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        System.out.println("Executing asyncMethod in thread: " + Thread.currentThread().getName());
    }
}

解決方法： 使用Future、CompletableFuture或ListenableFuture等返回值型別處理非同步結果。

8. 最佳實踐

選擇合適的執行緒池：根據應用的併發需求選擇合適的執行緒池配置，避免執行緒池過大或過小影響效能。
避免阻塞操作：在非同步方法中避免進行阻塞操作，確保執行緒池資源的高效使用。
處理異常：確保處理非同步方法中的異常，避免未處理異常導致的系統不穩定。
合理使用返回值：使用CompletableFuture等機制處理非同步方法的返回值和異常，提升程式碼的可讀性和可靠性。

9. 總結

@Async註解為Spring Boot應用提供了強大的非同步處理能力，透過減少主執行緒的阻塞，提升了應用程式的響應能力和吞吐量。合理使用@Async註解、配置自定義執行緒池、處理非同步異常以及選擇合適的返回值型別，都有助於提高非同步程式設計的效率和穩定性。瞭解常見的失效場景並避免它們，對於構建高效能、高併發的系統至關重要。

詳解 Spring Boot 中的 @Async 註解

1. `@Async`註解概述

2. 啟用非同步處理

3. 使用`@Async`註解

3.1 基本示例

4. 返回值

4.1 使用`Future`

4.2 使用`CompletableFuture`

5. 執行緒池配置

6. 異常處理

7. 常見失效場景

7.1 非同步方法呼叫自身

7.2 非public方法

7.3 同一類中呼叫

7.4 不支援的返回型別

8. 最佳實踐

9. 總結

相關推薦

同是優秀的日誌框架，lo...

Spring Boot整...

從多執行緒設計模式到對 ...

巧用反射與註解快速提取類...

從底層記憶體層面分析 J...

基於 Java 輕鬆實現...

0則評論

詳解 Spring Boot 中的 @Async 註解

1. @Async註解概述

2. 啟用非同步處理

3. 使用@Async註解

3.1 基本示例

4. 返回值

4.1 使用Future

4.2 使用CompletableFuture

5. 執行緒池配置

6. 異常處理

7. 常見失效場景

7.1 非同步方法呼叫自身

7.2 非public方法

7.3 同一類中呼叫

7.4 不支援的返回型別

8. 最佳實踐

9. 總結

相關推薦

0則評論

1. `@Async`註解概述

3. 使用`@Async`註解

4.1 使用`Future`

4.2 使用`CompletableFuture`