SpringBoot2 projet back-end - tâches régulières exemples

Avant d' utiliser JDK1.5 sont minuterie minuterie pour terminer la tâche, et il y a un seul thread pour effectuer des tâches régulières , et donc les problèmes suivants:

L'interaction entre les tâches multiples (tant que l'on n'attrape pas l'exception, d'autres tâches prendront fin automatiquement)
Multi-tâches est de série, inefficace

1.2 Exemples

requête POST envoyée en utilisant PostMan: localhost: 8888 / ruoyi / login, paramètres de la requête: nom d'utilisateur, mot de passe, code d'authentification, UUID

couche contrôleur reçoit la demande, et traiter la demande appelle la couche de service

le calendrier de lancement de la tâche de deux couches sercie

Une tâche est retardé de trois secondes pour imprimer le nom d'utilisateur, mot de passe, code d'authentification et le nom du fil et UUID

Une autre tâche est retardée 1 seconde d' intervalle de 1 seconde le temps d'impression et le nom du thread courant

1.3 demande d'extrémité avant

1.4 couche contrôleur

package com.ruoyi.project.system.controller;
/**
 * 登录验证
 *
 * @author ruoyi
 */
@RestController
public class SysLoginController {

    @Resource
    private SysLoginService loginService;

    @PostMapping("/login")
    public AjaxResult login(String username, String password, String code, String uuid) {
        AjaxResult ajax = AjaxResult.success();
        // 生成令牌
        String token = loginService.login(username, password, code, uuid);
        ajax.put(Constants.TOKEN, token);
        return ajax;
    }

}

1.5 Service Layer

1.6 résultats

2, un calendrier basé sur la tâche ScheduledExecutorService

2.1 introduction

ScheduledExecutorService est JDK1.5 apparaît, sur la base multithread, indépendamment l'un de l'autre entre les fils

2.2 Exemples

Dans l'exemple précédent, nous avons constaté que la tâche accomplie par minuterie minuterie, tant qu'il ya une exception se produit alors qu'une tâche n'est pas traitée, d'autres tâches seront terminées! !

Cet exemple résoudra ce problème.

2.3 Service Layer

Les demandes de contrôleur et des couches distales du même code ne se répète pas ici

2.4 fil journal d'impression d'exception

package com.ruoyi.common.utils;
/**
 * 线程相关工具类.
 *
 * @author ruoyi
 */
public class Threads {

    private static final Logger logger = LoggerFactory.getLogger(Threads.class);


    /**
     * 打印线程异常信息
     */
    public static void printException(Runnable r, Throwable t) {
        if (t == null && r instanceof Future<?>) {
            try {
                Future<?> future = (Future<?>) r;
                if (future.isDone()) {
                    future.get();
                }
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
        }
        if (t != null) {
            logger.error(t.getMessage(), t);
        }
    }

}

2.5 Résultats d'exploitation

3, pour améliorer

Sur un ScheduledExecutorService de cas nouveaux objets sont sortis, ce n'est pas bon codage!

①, les objets ScheduledExecutorService doivent être complétées par la gestion des conteneurs printemps.

②, devrait ScheduledExecutorService encapsule le gestionnaire de tâches asynchrones pour faire un seul mode de réalisation de

3.1 fil classe de configuration de la piscine

La classe de configuration, l'objet est injecté dans le récipient à ressort ScheduledExecutorService

package com.ruoyi.framework.config;
/**
 * 线程池配置
 *
 * @author ruoyi
 **/
@Configuration
public class ThreadPoolConfig {
    // 核心线程池大小
    private int corePoolSize = 50;

    /**
     * 执行周期性或定时任务
     */
    @Bean(name = "scheduledExecutorService")
    protected ScheduledExecutorService scheduledExecutorService() {
        return new ScheduledThreadPoolExecutor(corePoolSize,
                new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build()) {
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
                Threads.printException(r, t);
            }
        };
    }

}

3.2 Asynchronous Gestionnaire des tâches

package com.ruoyi.framework.manager;
/**
 * 异步任务管理器
 *
 * @author ruoyi
 */
public class AsyncManager {

    /**
     * 操作延迟10毫秒
     */
    private final int OPERATE_DELAY_TIME = 10;

    /**
     * 异步操作任务调度线程池
     */
    private ScheduledExecutorService executor = SpringUtils.getBean("scheduledExecutorService");

    /**
     * 单例模式
     */
    private AsyncManager() {
    }

    private static AsyncManager me = new AsyncManager();

    public static AsyncManager me() {
        return me;
    }

    /**
     * 执行任务
     *
     * @param task 任务
     */
    public void execute(TimerTask task) {
        executor.schedule(task, OPERATE_DELAY_TIME, TimeUnit.MILLISECONDS);
    }

}