【daisy-framework】延时任务(DelayTask)

前言

Github:https://github.com/yihonglei/daisy-framework/tree/master/daisy-springboot-framework(daisy工程)

一 延时任务

延时任务依靠延时队列实现。我们有定时任务了,为什么还需要延时任务?

假如一个线程每隔5s去处理一次业务,这个业务依赖别的条件,有可能处理成功,有可能处理失败,

如果处理成功,则线程退出,如果处理失败,我们需要让任务隔5s再次去处理,如果处理失败,

继续5s周期去处理,但是,这个任务经过20s的时候还是没有处理业务成功,线程退出,不继续处理。

这个场景是假设的场景,通过别的很多手段都能实现,这里讨论用延时任务实现这个业务模型。

二 延时任务场景代码

1、延时任务

定义任务超时时间比较算法。

package com.jpeony.common.concurrent;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 延时任务
 *
 * @author yihonglei
 */
public class DelayTask<T extends Runnable> 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;
    }
}

2、延时任务管理器

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<DelayTask<?>> 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<Thread, StackTraceElement[]> 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);
    }
}

3、线程抽象类

这个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();
}

4、任务线程

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);
    }
}

5、业务代码

 任务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);
    }
}

6、调用入口

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、业务里面自己根据条件决定要不然放入延时队列;

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值