【daisy-framework】延時任務設計（DelayTask）

前言

Github：https://github.com/yihonglei/daisy-framework

一 延時任務

延時任務依靠延時隊列實現。我們有定時任務了，爲什麼還需要延時任務？

假如一個線程每隔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、業務裏面自己根據條件決定要不然放入延時隊列；