Github:https://github.com/yihonglei/daisy-framework
延时任务依靠延时队列实现。我们有定时任务了,为什么还需要延时任务?
假如一个线程每隔5s去处理一次业务,这个业务依赖别的条件,有可能处理成功,有可能处理失败,
如果处理成功,则线程退出,如果处理失败,我们需要让任务隔5s再次去处理,如果处理失败,
继续5s周期去处理,但是,这个任务经过20s的时候还是没有处理业务成功,线程退出,不继续处理。
这个场景是假设的场景,通过别的很多手段都能实现,这里讨论用延时任务实现这个业务模型。
定义任务超时时间比较算法。
package com.jpeony.common.concurrent;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
/**
* 延时任务
*
* @author yihonglei
*/
public class DelayTask implements Delayed {
private final long time;
private final T task;
/**
* @param timeout 超时时间(秒)
* @param task 任务
*/
public DelayTask(long timeout, T task) {
this.time = System.nanoTime() + timeout;
this.task = task;
}
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(this.time - System.nanoTime(), TimeUnit.NANOSECONDS);
}
@Override
public int compareTo(Delayed o) {
DelayTask other = (DelayTask) o;
long diff = time - other.time;
if (diff > 0) {
return 1;
} else if (diff < 0) {
return -1;
} else {
return 0;
}
}
@Override
public int hashCode() {
return task.hashCode();
}
public T getTask() {
return task;
}
}
1)延时队列
2)定义队列监控线程
3)延时任务添加和删除
ThreadUtil线程池工具类,在Github工程daisy-framework的daisy下可以看到源码,
定义了CPU密集型和参考Tomcat源码定义的IO密集型线程池。
package com.jpeony.common.concurrent;
import com.jpeony.common.util.ThreadUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;
/**
* 延时队列管理器
*
* @author yihonglei
*/
public class DelayQueueManager {
private static final Logger logger = LoggerFactory.getLogger(DelayQueueManager.class);
/**
* 延时队列
*/
private DelayQueue> delayQueue;
/**
* 单利模式(懒汉式静态常量)
*/
private static DelayQueueManager instance = new DelayQueueManager();
private DelayQueueManager() {
delayQueue = new DelayQueue<>();
init();
}
public static DelayQueueManager getInstance() {
return instance;
}
/**
* 初始化
*/
private void init() {
/*
* 监控线程
*/
Thread monitorThread = new Thread(this::monitorExecute);
monitorThread.setName("DelayQueueMonitor");
monitorThread.start();
logger.info("延时队列管理器初始化完成...");
}
/**
* 延时队列监控逻辑
*/
private void monitorExecute() {
logger.info("启动了...");
for (; ; ) {
Map map = Thread.getAllStackTraces();
logger.info("当前存活线程数量:{}", map.size());
int taskNum = delayQueue.size();
logger.info("当前延时任务数量:{}", taskNum);
try {
DelayTask> delayTask = delayQueue.take();
Runnable task = delayTask.getTask();
logger.info("task:[{}]", task);
if (null == task) {
continue;
}
// 任务提交线程池执行
ThreadUtil.execute(task);
} catch (Exception e) {
logger.error("监控延时队列线程异常!", e);
}
}
}
/**
* 添加任务
*
* @param task 延时任务
* @param time 延时时间
* @param unit 时间单位
*/
public void put(Runnable task, long time, TimeUnit unit) {
long timeout = TimeUnit.NANOSECONDS.convert(time, unit);
DelayTask> delayTask = new DelayTask<>(timeout, task);
delayQueue.put(delayTask);
}
/**
* 删除任务
*/
public boolean removeTask(DelayTask task) {
return delayQueue.remove(task);
}
}
这个TraceItemDTO可以忽略,这个是工程里打印追踪TraceId用的。
package com.jpeony.common.concurrent;
import com.jpeony.common.pojo.dto.TraceItemDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 没有返回值的业务工作线程
*
* @author yihonglei
*/
public abstract class AbstractWorker implements Runnable {
protected Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void run() {
TraceItemDTO item = getTraceItem();
try {
item.putAll();
execute();
} catch (Throwable e) {
logger.error("线程执行异常", e);
} finally {
item.removeAll();
}
}
/**
* 返回追踪日志信息
*/
protected abstract TraceItemDTO getTraceItem();
/**
* 执行线程方法
*/
protected abstract void execute();
}
package com.jpeony.core.worker;
import com.jpeony.common.concurrent.AbstractWorker;
import com.jpeony.common.pojo.dto.TraceItemDTO;
import com.jpeony.common.spring.SpringBeanUtil;
import com.jpeony.core.service.DelayService;
import com.jpeony.core.service.delay.DelayServiceImpl;
import java.util.Date;
/**
* @author yihonglei
*/
public class DelayTaskWorker extends AbstractWorker {
private long passTime;
private Date startTime;
private DelayService delayService;
/**
* 日志追踪对象
*/
private TraceItemDTO traceItemDTO;
public DelayTaskWorker(long passTime, Date startTime) {
this.passTime = passTime;
this.startTime = startTime;
traceItemDTO = TraceItemDTO.createByCurrentMDC();
delayService = SpringBeanUtil.getBean(DelayServiceImpl.class);
}
/**
* ignore
*/
@Override
protected TraceItemDTO getTraceItem() {
return this.traceItemDTO;
}
/**
* 模拟每个3秒执行一次任务,超过20秒后自动退出任务
*/
@Override
protected void execute() {
delayService.delayTask(passTime, startTime);
}
}
任务5s执行一次,没有成功,就放入延时队列,20s后自动退出,
比如在10s就处理业务成功,只要不往延时队列继续放任务,线程也不会执行。
package com.jpeony.core.service;
import java.util.Date;
public interface DelayService {
/**
* @param passTime 过去时间
* @param startTime 开始时间
*/
void delayTask(long passTime, Date startTime);
}
package com.jpeony.core.service.delay;
import com.jpeony.common.concurrent.DelayQueueManager;
import com.jpeony.core.service.DelayService;
import com.jpeony.core.worker.DelayTaskWorker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.concurrent.TimeUnit;
/**
* @author yihonglei
*/
@Service
public class DelayServiceImpl implements DelayService {
private Logger logger = LoggerFactory.getLogger(DelayServiceImpl.class);
private DelayQueueManager delayQueueManager = DelayQueueManager.getInstance();
@Override
public void delayTask(long passTime, Date startTime) {
logger.info("测试延时任务,passTime={}", passTime);
logger.info("写你的业务代码。。。。。。");
// 判断过去多久了
passTime = (System.currentTimeMillis() - startTime.getTime()) / 1000;
if (passTime > 20) {
logger.info("任务结束!");
return;
}
// 加入延时队列
DelayTaskWorker delayTaskWorker = new DelayTaskWorker(passTime, startTime);
delayQueueManager.put(delayTaskWorker, 5, TimeUnit.SECONDS);
}
}
package com.jpeony.test.service.worker;
import com.jpeony.common.util.ThreadUtil;
import com.jpeony.core.service.DelayService;
import com.jpeony.test.BaseServletTest;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.Date;
import java.util.concurrent.ExecutionException;
/**
* 测试下线程
*
* @author yihonglei
*/
@Slf4j
public class WorkerTest extends BaseServletTest {
@Autowired
private DelayService delayService;
/**
* 延时任务测试
*/
@Test
public void testDelayTask() {
delayService.delayTask(0, new Date());
sleep();
}
public void sleep() {
try {
Thread.sleep(30000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行效果:
1、延时任务实现Delayed,定义你的比较算法等;
2、每次任务其实都是放在延时队列里面;
3、延时队列管理,主要是监控线程,用于监控延时队列,从延时队列取任务提交到线程池执行;
4、业务里面自己根据条件决定要不然放入延时队列;