基于springboot实现轮询线程自动执行任务

本文使用：

　　Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，

但不能在指定时间运行。一般用的较少。

类似于quartz任务调度：demo地址 lsr-core-base模块中

直接上代码：

线程基类：

package cn.lsr.core.thread;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.sql.Timestamp;

import java.util.Timer;

import java.util.TimerTask;

/**

 * @Description: 轮询线程基类

 * @Package: lsr-microservice

 * @author: Hacker_lsr@126.com

 **/

public abstract class AbstractPollThread {

    private static final Logger log = LoggerFactory.getLogger(AbstractPollThread.class);

    private long delay = 60; // 延期时间(第一次执行时间-调用时间)

    private long timeInterval = 60; //时间间隔(s)

    private Timer timer;

    private Timestamp lastProcess = null; //上次执行的时间

    private boolean isTimerStart = false; //定时器是否启动

    private boolean isOnProcessing = false; //是否在执行处理

    private final String threadName; //线程名称

    private final String threadId; //线程标识

    private final String longname; //中文名称

    private long processCount = 0; //执行次数

    private long processTime = 0; //已运行时间

    private long errorProcessCount = 0; //执行失败的次数

    public AbstractPollThread(String threadId, String threadName, String longname, Long delay, Long timeInterval) {

        this.threadId = threadId;

        this.threadName = threadName;

        this.longname = longname;

        if (timeInterval != null && timeInterval > 0)

            this.timeInterval = timeInterval;

        if (delay != null)

            this.delay = delay;

        PollThreadManager.get().register(threadName, this);

    }

    /**

     * 线程启动时回调方法。

     */

    public void init() {

    }

    /**

     * 轮询间隔回调方法。

     */

    public abstract void process();

    /**

     * 启动方法

     */

    public void startup() {

        this.timer = new Timer( "lsr-timer-" + this.threadName, false);

        try {

            this.timer.schedule(new TimerTask() {

                boolean initialized = false;

                @Override

                public void run() {

                    // 异步线程资源清理

                    //清理完上下文数据，在打log4j标记

                    log.info("--------------------轮训线程[" + AbstractPollThread.this.threadName + "]开始调度--------------------");

                    // 2015.4.20 每个线程开始受理请求时对数据库连接进行检查，若不可用则重连一次

                    long start = System.currentTimeMillis();

                    try {

                        AbstractPollThread.this.isOnProcessing = true;

                        AbstractPollThread.this.lastProcess = new Timestamp(System.currentTimeMillis());

                        AbstractPollThread.this.process();

                        AbstractPollThread.this.isOnProcessing = false;

                    }

                    catch (Throwable t) {

                         log.error("轮询线程出现异常", t);

                        AbstractPollThread.this.errorProcessCount++;

                    } finally {

                        AbstractPollThread.this.processCount++;

                        AbstractPollThread.this.processTime = AbstractPollThread.this.processTime + System.currentTimeMillis() - start;

                        log.info("--------------------轮训线程[" + AbstractPollThread.this.threadName + "]调度结束. [" + (System.currentTimeMillis() - start) + "]--------------------");

                        //  异步线程资源清理

                    }

                }

            }, this.delay * 1000, this.timeInterval * 1000);

            this.isTimerStart = true;

        } catch (Exception e) {

            this.isTimerStart = false;

            log.error("轮询线程设置定时器失败,", e);

            throw new RuntimeException("轮询线程设置定时器失败", e);

        }

    }

    public void shutdown() {

        try {

            if (this.timer != null)

                this.timer.cancel();

            this.isTimerStart = false;

        } catch (Exception e) {

            this.isTimerStart = false;

            log.error("关闭轮询线程中的定时器失败", e);

            throw new RuntimeException("关闭轮询线程中的定时器失败", e);

        }

    }

    public String getThreadName() {

        return this.threadName;

    }

    public String getLongname() {

        return this.longname;

    }

    public long getProcessCount() {

        return this.processCount;

    }

    public long getProcessTime() {

        return this.processTime;

    }

    public long getErrorProcessCount() {

        return this.errorProcessCount;

    }

    public void setTimeInterval(long timeInterval) {

        this.timeInterval = timeInterval;

    }

    public long getTimeInterval() {

        return this.timeInterval;

    }

    public boolean isTimerStart() {

        return this.isTimerStart;

    }

    public boolean isOnProcessing() {

        return this.isOnProcessing;

    }

    public String getLastProcessTime() {

        return this.lastProcess == null ? null : this.lastProcess.toString();

    }

    public void resetCountInfo() {

        this.processCount = 0;

        this.processTime = 0;

        this.errorProcessCount = 0;

        this.lastProcess = null;

    }

}

轮询线程配置类：

package cn.lsr.core.thread;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.Configuration;

/**

 * @Description: 轮询线程配置

 * @Package: lsr-microservice

 * @author: Hacker_lsr@126.com

 **/

public class PollThreadConfig {

    /**

     * 轮询线程ID

     */

    private String threadId;

    /**

     * 轮询线程名称

     */

    private String threadName;

    /**

     * 间隔时间

     */

    private Long timeInterval;

    /**

     * 轮询线程首次延迟时间

     */

    private Long delay;

    // get set 省略

}

线程管理器：

package cn.lsr.core.thread;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

/**

 * @Description: 线程管理器

 * @Package: lsr-microservice

 * @author: Hacker_lsr@126.com

 **/

public class PollThreadManager {

    private final static Map<String, AbstractPollThread> pollThreadMap = new ConcurrentHashMap<String, AbstractPollThread>();

    private final static PollThreadManager instance = new PollThreadManager();

    public static PollThreadManager get() {

        return instance;

    }

    public void register(String threadName, AbstractPollThread pollThread) {

        pollThreadMap.put(threadName, pollThread);

    }

    public AbstractPollThread getPollThread(String threadName) {

        return pollThreadMap.get(threadName);

    }

    public Map<String, AbstractPollThread> getPollThreads() {

        return pollThreadMap;

    }

}

测试线程(可扩展)：

package cn.lsr.core.thread;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.sql.Timestamp;

/**

 * @Description: 测试轮询线程

 * @Package: lsr-microservice

 * @author: Hacker_lsr@126.com

 **/

public class TestServerPollThread extends AbstractPollThread{

    private static final Logger log = LoggerFactory.getLogger(TestServerPollThread.class);

    /**

     * 插件     - OnlineServerManagerPlugin -启动的时候初始化线程

     * @param threadId 轮询线程ID

     * @param threadName 轮询线程名称

     * @param longname  中文名称

     * @param delay 轮询线程首次延迟时间

     * @param timeInterval 时间间隔

     */

    public TestServerPollThread(String threadId, String threadName, String longname, Long delay, Long timeInterval) {

        super(threadId, threadName, longname, delay, timeInterval);

    }

    /**

     * 轮询间隔回调方法

     */

    @Override

    public void process() {

        log.info("刷新时间为：{}", new Timestamp(System.currentTimeMillis()));

       //逻辑

    }

}

使用：

//注入：

private TestServerPollThread testServerPollThread;

// 封装的工具类，获取的ioc的线程配置

PollThreadConfig pollThreadConfig = SpringUtil.getBean(PollThreadConfig.class);

testServerPollThread = new TestServerPollThread(pollThreadConfig.getThreadId(),pollThreadConfig.getThreadName(),pollThreadConfig.getThreadName(),pollThreadConfig.getDelay(),pollThreadConfig.getTimeInterval());

//调用方法

testServerPollThread.startup();

application.properties:

##################################### 轮询线程 #######################################
#开关

lsr.poll.thread.enabled=true
#线程id

lsr.poll.thread.threadId=LSRThread
#线程中文名

lsr.poll.thread.threadName=轮询线程
#间隔时间

lsr.poll.thread.timeInterval=60
#加载延迟时间

lsr.poll.thread.delay=60

巴特西

基于springboot实现轮询线程自动执行任务

最新文章

热门文章