【daisy-framework】延时任务（DelayTask）

最新推荐文章于 2024-08-10 07:18:36 发布

街灯下的小草

最新推荐文章于 2024-08-10 07:18:36 发布

阅读量1.1k

点赞数

分类专栏：架构设计文章标签：延时任务线程池延时队列并发编程

本文链接：https://blog.csdn.net/yhl_jxy/article/details/106750450

版权

架构设计专栏收录该内容

32 篇文章 2 订阅

订阅专栏

前言

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

运行效果：