So nutzen Sie Multithreading elegant in SpringBoot

Schnelle Verwendung

Die Annotation @EnableAsync muss zur SpringBoot-Anwendung hinzugefügt werden, um asynchrone Aufrufe zu ermöglichen. Im Allgemeinen wird ein Thread-Pool konfiguriert und die asynchrone Methode zur Vervollständigung an einen bestimmten Thread-Pool übergeben:

@Configuration
@EnableAsync
public class AsyncConfiguration {
 
    @Bean("doSomethingExecutor")
    public Executor doSomethingExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池创建时候初始化的线程数
        executor.setCorePoolSize(10);
        // 最大线程数：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(20);
        // 缓冲队列：用来缓冲执行任务的队列
        executor.setQueueCapacity(500);
        // 允许线程的空闲时间60秒：当超过了核心线程之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix("do-something-");
        // 缓冲队列满了之后的拒绝策略：由调用线程处理（一般是主线程）
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        executor.initialize();
        return executor;
    }
 
}

Die Verwendungsmethode ist sehr einfach. Fügen Sie die @Async-Annotation zu Methoden hinzu, die asynchrone Methoden erfordern.

@RestController
public class AsyncController {
 
    @Autowired
    private AsyncService asyncService;
 
    @GetMapping("/open/something")
    public String something() {
        int count = 10;
        for (int i = 0; i < count; i++) {
            asyncService.doSomething("index = " + i);
        }
        return "success";
    }
}
 
 
@Slf4j
@Service
public class AsyncService {
 
    // 指定使用beanname为doSomethingExecutor的线程池
    @Async("doSomethingExecutor")
    public String doSomething(String message) {
        log.info("do something, message={}", message);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            log.error("do something error: ", e);
        }
        return message;
    }
}

Zugriff: 127.0.0.1:8080/open/something, das Protokoll lautet wie folgt:

2023-02-06 23:42 :42.486 INFO 21168 --- [io-8200-exec -17] x.g.b.system.controller.AsyncController: etwas tun, Ende, Zeit 8 Millisekunden
2023-02-06 23:42:42.488 INFO 21168 --- [ etwas tun -1] x.gits.boot.system.service: etwas tun, message=index = 0
2023-02-06 23:42:42.488 INFO 21168 --- [do-something-5] x.gits. boot.system.service.AsyncService: etwas tun, message= index = 4
2023-02-06 23:42:42.488 INFO 21168 --- [do-something-4] x.gits.boot.system.service.AsyncService : etwas tun, message=index = 3
2023-02 -06 23:42:42.488 INFO 21168 --- [do-something-6] x.gits.boot.system.service.AsyncService: etwas tun, message=index = 5
2023-02-06 23:42:42.488 INFO 21168 --- [ do-something-9] x.gits.boot.system.service.AsyncService : etwas tun, message=index = 8
2023-02- 06 23:42:42.488 INFO 21168 --- [ do -something-8] x.gits.boot.system.service.AsyncService : etwas tun, message=index = 7
2023-02-06 23:42:42.488 INFO 21168 --- [do-something-10] x. gits.boot.system.service.AsyncService: etwas tun, message=index = 9
2023-02-06 23:42:42.488 INFO 21168 --- [do- Something-7] x.gits.boot.system.service .AsyncService: etwas tun, message=index = 6
2023-02-06 23:42:42.488 INFO 21168 --- [do-something-2] x.gits .boot.system.service.AsyncService: etwas tun, Nachricht =index = 1
2023-02-06 23:42:42.488 INFO 21168 --- [do-something-3] x.gits.boot.system.service. AsyncService: etwas tun, message=index = 2

Es ist ersichtlich, dass der Effekt der asynchronen Ausführung erreicht wurde und der von uns konfigurierte Thread-Pool verwendet wurde.

Rufen Sie den Rückgabewert der asynchronen Methode ab.

Wenn die asynchrone Methode einen Rückgabewert hat, wie erhält man das Rückgabeergebnis der asynchronen Methodenausführung? Zu diesem Zeitpunkt hat die Methode, die asynchron aufgerufen werden muss, den Rückgabewert CompletableFuture.

CompletableFuture ist eine Erweiterung von Feature. Feature kann nur einfache asynchrone Aufgaben verarbeiten, während CompletableFuture komplexe Kombinationen mehrerer asynchroner Aufgaben ausführen kann. Wie folgt:

@RestController
public class AsyncController {
 
    @Autowired
    private AsyncService asyncService;
 
    @SneakyThrows
    @ApiOperation("异步 有返回值")
    @GetMapping("/open/somethings")
    public String somethings() {
        CompletableFuture<String> createOrder = asyncService.doSomething1("create order");
        CompletableFuture<String> reduceAccount = asyncService.doSomething2("reduce account");
        CompletableFuture<String> saveLog = asyncService.doSomething3("save log");
 
        // 等待所有任务都执行完
        CompletableFuture.allOf(createOrder, reduceAccount, saveLog).join();
        // 获取每个任务的返回结果
        String result = createOrder.get() + reduceAccount.get() + saveLog.get();
        return result;
    }
}
 
 
@Slf4j
@Service
public class AsyncService {
 
    @Async("doSomethingExecutor")
    public CompletableFuture<String> doSomething1(String message) throws InterruptedException {
        log.info("do something1: {}", message);
        Thread.sleep(1000);
        return CompletableFuture.completedFuture("do something1: " + message);
    }
 
    @Async("doSomethingExecutor")
    public CompletableFuture<String> doSomething2(String message) throws InterruptedException {
        log.info("do something2: {}", message);
        Thread.sleep(1000);
        return CompletableFuture.completedFuture("; do something2: " + message);
    }
 
    @Async("doSomethingExecutor")
    public CompletableFuture<String> doSomething3(String message) throws InterruptedException {
        log.info("do something3: {}", message);
        Thread.sleep(1000);
        return CompletableFuture.completedFuture("; do something3: " + message);
    }
}

Zugriffsschnittstelle

C:UsersAdministrator>curl -X GET "http://localhost:8080/open/something" -H "accept: */*"
do Something1: create order;
do etwas2: Konto reduzieren;
etwas tun3: Protokoll speichern

Die Schlüsselprotokolle auf der Konsole lauten wie folgt:

2023-02-06 00:27:42.238 INFO 5672 --- [do-something-3] x .gits.boot .system.service.AsyncService: etwas tun3: Protokoll speichern
2023-02-06 00:27:42.238 INFO 5672 --- [do-something-2] x.gits.boot.system.service.AsyncService : etwas tun2: Konto reduzieren
2023-02-06 00:27:42.238 INFO 5672 --- [do-something-1] x.gits.boot.system.service.AsyncService: etwas tun1: Bestellung erstellen

Notizen

@ Async-Annotationen schlagen in den folgenden Szenarien fehl, was bedeutet, dass die @Async-Annotation eindeutig verwendet wird, Multithreading jedoch nicht.

• Asynchrone Methoden werden mit dem Schlüsselwort static geändert

• Die asynchrone Klasse ist keine Bean des Spring-Containers (im Allgemeinen mit @Component und @Service versehen und kann von Spring gescannt werden);

• Nicht in SpringBoot-Anwendungen verfügbar. Fügen Sie die Annotation @EnableAsync hinzu.

• Wenn in derselben Klasse eine Methode eine andere mit @Async annotierte Methode aufruft, wird die Annotation nicht wirksam. Der Grund dafür ist, dass die mit @Async annotierte Methode in der Proxy-Klasse ausgeführt wird.

Es ist zu beachten, dass der Rückgabewert einer asynchronen Methode, die die @Async-Annotation verwendet, nur void oder Future und ihre Unterklassen sein kann. Wenn das Rückgabeergebnis andere Typen hat, wird die Methode weiterhin asynchron ausgeführt Der Rückgabewert ist null. Ein Teil des Quellcodes lautet wie folgt:

AsyncExecutionInterceptor#invoke

Durch die obigen Beispiele wird @Async tatsächlich asynchron über Future oder CompletableFuture ausgeführt, und Spring kapselt es, um es bequemer zu machen für uns zur Nutzung.

Das obige ist der detaillierte Inhalt vonSo nutzen Sie Multithreading elegant in SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!