Méthodes appelées de manière asynchrone par @Async en Java

Avant-propos

Appel asynchrone et appel synchrone

• Appel synchrone : Exécuter séquentiellement, exécuter à nouveau l'appel suivant en renvoyant le résultat de l'appel

• Appel asynchrone : Exécuter le prochain appel sans attendre le return result Appel

1. Explication @Async

Le code d'annotation de @Async est le suivant :

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Async {
    String value() default "";
}

Les annotations peuvent être utilisées dans les types et les méthodes
La valeur est définie par valeur et la valeur par défaut est vide

Généralement, cette annotation doit correspondre à @EnableAsync , le code d'origine est le suivant

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AsyncConfigurationSelector.class})
public @interface EnableAsync {
    Class<? extends Annotation> annotation() default Annotation.class;

    boolean proxyTargetClass() default false;

    AdviceMode mode() default AdviceMode.PROXY;

    int order() default Integer.MAX_VALUE;
}

Principalement placé dans la classe de démarrage via cette annotation pour le démarrage de la configuration

Ajoutez ce qui suit dans la classe de démarrage :

@SpringbootApplication
@EnableAsync
public class Application{
    public static void main(String[] args){
        SrpingApplication.run(Application.class, args);
    }
}

Utilisation

2.

2.1 Appel synchrone

Le résultat de la fonction ne peut être exécuté qu'à partir de l'appel jusqu'au retour Une étape, appelée appel synchrone

Code de la couche de service :

public class Service{
    public void test01() throws InterruptedException{
        Thread.sleep(5000);
        System.out.println("保存日志");
    }
}

Module de code de la couche de contrôle :

public class Controler{
    @Autowired
    private Service service;

    @GetMapping("/test")
    public String getTest(){
        try{
            System.out.println("开始");
            service.test01();
            System.out.println("结束");            
        }catch(InterruptedException e){
            e.prinStackTrace();
        }
    }
    
}

Après avoir démarré via la classe de démarrage de Springboot

Le résultat est le suivant :

Début

//Il s'agit d'attendre 5 secondes, Le terminal n'est ni affiché ni fermé

Fin

2.2 Appel asynchrone

Appel asynchrone, la fonction en cours d'exécution peut s'exécuter l'étape suivante sans attendre le résultat de retour

Code de la couche de service :
Ajout principal de l'annotation @Async pour identifier cette méthode

public class Service{
    @Async
    public void test01() throws InterruptedException{
        Thread.sleep(500);
        System.out.println("保存日志");
    }
}

Module de code de la couche de contrôle :

Démarrez @EnableAsync en appelant la fonction de couche de service

public class Controler{
    @Autowired
    private Service service;

    @GetMapping("/test")
    public String getTest(){
        try{
            System.out.println("开始");
            service.test01();
            System.out.println("结束");            
        }catch(InterruptedException e){
            e.prinStackTrace();
        }
    }
    
}

et en ajoutant annotations à la classe de démarrage

@SpringbootApplication
@EnableAsync
public class Application{
    public static void main(String[] args){
        SrpingApplication.run(Application.class, args);
    }
}

3. Personnaliser le pool de threads

Pour des connaissances de base sur le pool de threads, veuillez consulter mon article précédent :

Comment fermer correctement les threads et les pools de threads en Java (la pratique du code inclut l'analyse du code source )
Analyse détaillée de la façon de créer un pool de threads Java (complet)

Si vous ne spécifiez pas de pool de threads, le pool de threads par défaut utilisé est SimpleAsyncTaskExecutor (quand une tâche arrive, créez simplement un thread. La création continue de threads entraînera le CPU trop élevé et provoque un MOO). Le pool de threads intégré présente généralement des inconvénients. Il est généralement recommandé d'utiliser ThreadPoolExecutor (effacer les ressources du pool de threads et éviter les risques)

Les détails sont les suivants :

• newFixedThreadPool : Même si le nombre de threads est fixe, la file d'attente des tâches est toujours illimitée (le nombre maximum de threads ne sera créé que lorsque la file d'attente est pleine), cela provoquera donc un MOO

• newCachedThreadPool : Il n'y a pas de pool supérieur limite pour le nombre maximum de threads, et un grand nombre de threads sont créés. Facile à geler ou directement OOM

La configuration du pool de threads peut être ajustée via un pool de threads personnalisé pour une meilleure utilisation des ressources

@Async Cette annotation recherche le Interface AsyncConfigurer (la classe d'implémentation est AsyncConfigurerSupport, la configuration et les méthodes par défaut sont vides), de sorte que l'interface peut être remplacée pour spécifier le pool de threads.

• En implémentant l'interface AsyncConfigurer

• Hériter AsyncConfigurerSupport

• Custom TaskExecutor (en remplacement de l'exécuteur de tâches intégré)

La troisième méthode :

Définir des pools de threads dans l'application Variable .xml

thread.core.size=16
thread.max.size=16
thread.queue.size=30

thread.prefix=xx-

Le pool de threads personnalisés est le suivant

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

import java.util.concurrent.ThreadPoolExecutor;

@Configuration
public class ThreadPoolConfig {
    // 线程名称前缀
    @Value("${thread.prefix}")
    private String threadPrefix;
    
    // 核心线程数
    @Value("${thread.core.size}")
    private int coreSize;

    // 最大线程数
    @Value("${thread.max.size}")
    private int maxSize;
    
    // 队列长度
    @Value("${thread.queue.size}")
    private int queueSize;
    
    // 通过bean注解注入
    @Bean("xx")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //设置线程池参数信息
        taskExecutor.setCorePoolSize(coreSize);
        taskExecutor.setMaxPoolSize(maxSize);
        taskExecutor.setQueueCapacity(queueSize);
        taskExecutor.setThreadNamePrefix(threadPrefix);
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        taskExecutor.setAwaitTerminationSeconds(30);
        
        //修改拒绝策略为使用当前线程执行
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        
        //初始化线程池
        taskExecutor.initialize();
        return taskExecutor;
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!