SpringBoot 封裝異步、延遲執行任務簡單demo

 

 

ThreadPoolConfig.java

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.*;

/**
 * 線程池配置類
 **/
@Configuration
@Slf4j
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);
                printException(r, t);
            }
        };
    }


    /**
     * 打印線程異常信息
     */
    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) {
            log.error(t.getMessage(), t);
        }
    }
}

 

 

AsyncManager.java   (SpringUtils.java 參考：https://www.cnblogs.com/pxblog/p/15065785.html)

import lombok.extern.slf4j.Slf4j;

import java.util.TimerTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 異步任務管理器
 */
@Slf4j
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);
    }

    /**
     * 停止線程池
     */
    public void shutdown() {
        if (executor != null && !executor.isShutdown()) {
            executor.shutdown();
            try {
                if (!executor.awaitTermination(120, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                    if (!executor.awaitTermination(120, TimeUnit.SECONDS)) {
                        log.info("Pool did not terminate");
                    }
                }
            } catch (InterruptedException ie) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }


}

 

使用 demo

    @GetMapping(value = "/indexttest")
    public String index(){

        /**
         * 異步任務處理
         */
        AsyncManager.me().execute(new TimerTask() {
            @Override
            public void run() {
                System.out.println("我執行了異步任務");
            }
        });

        return "success";
    }

 

 

也可以單獨任務羅出來

AsyncFactory.java

import java.util.TimerTask;

public class AsyncFactory { /** * 同步任務 */ public static TimerTask syncJob() { return new TimerTask() { @Override public void run() { System.out.println("我在調用同步"); } }; } }

 

 

 

要加個處理 退出銷毀

  @PreDestroy
    public void destroy() {
        try {
            log.info("====關閉后台任務任務線程池====");
            AsyncManager.me().shutdown();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }