本文使用:
Timer:这是java自带的java.util.Timer类,这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行,
但不能在指定时间运行。一般用的较少。
类似于quartz任务调度: demo地址
直接上代码:
线程基类:
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