【基础组件设计实践】项目中实现延时任务的不同姿势

置顶 已于 2022-01-25 18:42:10 修改
阅读量679 收藏 1
点赞数 1
分类专栏： Java(SpringBoot)企业日常研发笔记 文章标签： springboot java 延时任务
于 2021-11-26 10:39:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36652619/article/details/121496787
版权

目录

介绍

一、 通过Redis的方式实现延时任务实现

定义延时任务调度器

具体的业务Handler封装

注册具体的Handler

二、使用云调度平台方式实现延时任务

延时任务的表结构

延时任务Service的实现

介绍

延时任务，一个非常常用和常见的技术组件：如订单下单后五分钟发邮件提醒用户过来查看，又或者定时任务失败后3分钟延时任务自动重试。延时任务的概念很简单，但是实现起来方法很多，下面来介绍一下平常项目用的两种。

一、 通过Redis的方式实现延时任务实现

实现说明：

  1. 注册延时任务：将具体的taskid和任务的参数还有执行时间保存在Redis
  2. 服务启动的时候会起一个轮询，每秒去轮询Redis提取出需要执行的延时任务
  3. 根据延时任务的taskId获取到具体的Handler处理器类型
  4. 根据Handler处理器的类型去获取内存中已经注册好的Handler去实现具体的业务

定义延时任务调度器

调度器接口类：

public interface DelayJobScheduleService {

    /**
     * 提交定时任务
     *
     * @param delayJob 提交定时任务
     * @return
     */
    boolean submitJob(DelayJob delayJob);
}

调度器具体实现（内附注释）：

import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.StrUtil;
import com.test.common.until.CompareUtils;
import com.test.common.until.GsonUtil;
import com.test.common.until.JacksonUtils;
import com.test.infra.delay.handler.DelayJobHandler;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.gson.reflect.TypeToken;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

/**
 * @date @date 11/23/2021 4:14 下午
 */
@Slf4j
@Component
@Order(200)
public class RedisDelayJobScheduleServiceImpl implements DelayJobScheduleService {

    @Resource
    private DelayJobStrategy delayJobStrategy;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private static final String DELAY_JOB_QUEUE_KEY = "delayJob::queue";

    private static String DELAY_JOB_BODY_KEY_PREFIX = "delayJob::body";

    private static final ScheduledExecutorService SINGLE_THREAD_EXECUTORS;

    static {
        String threadNameFormat = "delay-job-thread";
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat(threadNameFormat).build();
        SINGLE_THREAD_EXECUTORS = Executors.newSingleThreadScheduledExecutor(namedThreadFactory);
    }

    /**
     * 定时任务提交到Redis
     * @param delayJob 提交定时任务
     */
    @Override
    public boolean submitJob(DelayJob delayJob) {
        if (delayJob == null) {
            log.info("job is empty!");
            return false;
        }

        String msgContent = GsonUtil.toJsonString(delayJob.getMsgContent());
        String taskId = genTaskId(delayJob.getType());

        long currentTimeMillis = System.currentTimeMillis();
        long score = currentTimeMillis + delayJob.getDelayDuration();
        stringRedisTemplate.opsForZSet().add(DELAY_JOB_QUEUE_KEY, taskId, score);
        stringRedisTemplate.opsForValue().set(taskId, msgContent);
        log.info("submit delayJob:{} success! taskId:{} currentTimeMillis:{} score:{}", GsonUtil.toJsonString(delayJob), taskId, currentTimeMillis, score);
        return true;
    }

    /**
     * 生成TaskId
     *
     * @param delayMsgType
     * @return
     */
    private String genTaskId(DelayMsgType delayMsgType) {
        return Joiner.on(StrUtil.UNDERLINE)
                .join(DELAY_JOB_BODY_KEY_PREFIX,
                        //消息类型
                        delayMsgType.getCode(),
                        UUID.randomUUID().toString());
    }


    private DelayMsgType parseDelayMsgType(String taskId) {
        String delayMsgTypeCode = Splitter.on(StrUtil.UNDERLINE).splitToList(taskId).get(1);
        return DelayMsgType.getDelayMsgType(Integer.valueOf(delayMsgTypeCode));
    }

    /**
     * 服务启动时开启调度
     */
    @PostConstruct
    public void schedule() {
        ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
        ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();
        // 每一秒轮询
        SINGLE_THREAD_EXECUTORS.scheduleWithFixedDelay(new Runnable() {
            @Override
            @Trace
            public void run() {
                // 异常处理, 只打印日志
                Thread.currentThread().setUncaughtExceptionHandler((t1, e) -> {
                    log.error("execute delay job fail", e);
                });
                log.info("schedule delayJob");
                DelayJobHandler delayJobHandler = null;
                long score = System.currentTimeMillis();
                // 去除满足条件的延时任务
                Set<String> taskIdSet = zSetOperations.rangeByScore(DELAY_JOB_QUEUE_KEY, 0, score, 0, 1);
                if (CollectionUtils.isEmpty(taskIdSet)) {
                    return;
                }
                log.info("delayJob,taskIds: {}", JacksonUtils.toJsonStr(taskIdSet));
                for (String taskId : taskIdSet) {
                    if (CompareUtils.gt(zSetOperations.remove(DELAY_JOB_QUEUE_KEY, taskId), 0L)) {
                        String msgContent = valueOperations.get(taskId);
                        log.info("begin execute delayJob, taskId:{} msgContent:{},score:{}", taskId, msgContent, score);
                        DelayMsgType delayMsgType = parseDelayMsgType(taskId);
                        delayJobHandler = delayJobStrategy.getByType(delayMsgType);
                        if (delayJobHandler != null) {
                            delayJobHandler.handle(GsonUtil.toJavaBean(msgContent, TypeToken.get(delayMsgType.getParamClazz())));
                        }
                        stringRedisTemplate.delete(taskId);
                        log.info("finished execute delayJob,taskId:{}", taskId);
                    }
                    break;
                }
            }
        }, 1, 1, TimeUnit.SECONDS);
    }
}

具体的业务Handler封装

先来一个handler的抽象接口类：

public interface DelayJobHandler<T> {

    /**
     * 处理延时任务
     *
     * @param message
     */
    void handle(T message);

    /**
     * 类型
     *
     * @return
     */
    DelayMsgType delayMsgType();
}

定义延时任务的类型枚举

public enum DelayMsgType {
    

    ORDER_NOTIFY(1, "订单邮件提醒", PoNotifyDTO.class),
    RETRY_JOB(2, "定时任务失败重试", RetryDto.class),
    ;

    /**
     * 值
     */
    private final Integer code;

    /**
     * 描述
     */
    private final String desc;

    /**
     * 这个是你需要在延时任务传递的参数
     */
    private final Class paramClazz;


    public Integer getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }


    DelayMsgType(Integer code,
                 String desc,
                 Class paramClazz) {
        this.code = code;
        this.desc = desc;
        this.paramClazz = paramClazz;
    }

    public static DelayMsgType getDelayMsgType(Integer code) {
        for (DelayMsgType type : DelayMsgType.values()) {
            if (type.code.equals(code)) {
                return type;
            }
        }
        return null;
    }

    public Class getParamClazz() {
        return paramClazz;
    }

实现处理器，实现Handler封装接口：

@Slf4j
@Component
public class GenPoRetryHandler implements DelayJobHandler<RetryDto> {


    @Override
    public void handle(RetryDto message) {
        // 延时任务具体处理的业务逻辑
        .......
    }

    @Override
    public DelayMsgType delayMsgType() {
        // 返回具体的类型枚举
        return DelayMsgType.RETRY_JOB;
    }
}

注册具体的Handler

@Slf4j
@Component
public class DelayJobStrategy implements ApplicationContextAware {


    private Map<DelayMsgType, DelayJobHandler> strategyMap = new ConcurrentHashMap<>();

    public DelayJobHandler getByType(DelayMsgType delayMsgType) {
        return strategyMap.get(delayMsgType);
    }

    @Override
    public void setApplicationContext(ApplicationContext atx) throws BeansException {
        this.setBeanMap(atx, strategyMap);
    }


    private void setBeanMap(ApplicationContext atx,
                            Map<DelayMsgType, DelayJobHandler> beanMap) {
        String[] beanNames = atx.getBeanNamesForType(DelayJobHandler.class);
        for (String beanName : beanNames) {
            DelayJobHandler bean = atx.getBean(beanName, DelayJobHandler.class);
            DelayMsgType delayMsgType = bean.delayMsgType();
            beanMap.put(delayMsgType, bean);
        }

        if (log.isDebugEnabled()) {
            log.info("load {} beanMap success! \n beanMap detail:{}",
                    DelayJobHandler.class.getSimpleName(),
                    JSON.toJSONString(beanMap, SerializerFeature.WriteMapNullValue));
        }
    }
}

二、使用云调度平台方式实现延时任务

整体设计如上图所示，左边绿色的区域我们可以借助云平台的轻函数无服务serverless能力实现分钟级调度，例如腾讯云的：

或者云产品的分布式调度平台，如：

我们只需要在云平台配置分钟级的调度，然后在具体的业务服务里面实现延时任务的状态流转 / 执行 / 提交，将延时任务的调度和延时任务的管理解耦，这样的好处

1. 我们可以对延时任务管控起来，每个延时任务的状态，传参，执行时间，成功或失败，失败重试都变得清晰可见

2. 可以线上化配置我们的job调度时间，更改调度间隔，不需要重新去发版。

延时任务的表结构

任务表字段

id、type、handler、status、tigger_time、update_time、create_time

延时任务Service的实现

具体的时序图如下：

下面我们来实战一下，先定义接口：

public interface DelayJobScheduleService {

    /**
     * 延迟处理
     */
    void handleDelayJob();

    /**
     * 处理中断的延时任务
     */
    void handleAbnormalDelayJob();

    /**
     * 添加延时任务
     */
    void addJob(List<TriggerTaskInfo> triggerTasks);

}

 我们先用抽象实现接口，在抽象这里整体我们采用一个模板方法的设计模式，通过类型取延时任务的地方是通过反射去获取，表中落得是类的名称，延时任务的 提交 / 获取 / 执行 / 异常处理 / 定时回收中间状态任务机制 都在这个service中实现：

TriggerTaskInfo是数据表映射的实体类
PartitionUtils 是封装的一个多线程异步的工具类，后续会出文章介绍😄🎃
注意这里为什么要开手工事务：
无法使用@Transactional对一个非public的方法进行事务管理
另外：
类似下面这种自调用的事务是不生效的，原因以后的文章会总结

@Service
public class DmzService {
 
 public void saveAB(A a, B b) {
  saveA(a);
  saveB(b);
 }

 @Transactional
 public void saveA(A a) {
  dao.saveA(a);
 }
 
 @Transactional
 public void saveB(B b){
  dao.saveB(a);
 }
}

具体实现：

@Slf4j
public abstract class AbstractDelayJobHandler implements DelayJobScheduleService {

    @Resource
    private TriggerTaskRepository repository;
    @Resource(name = "triggerTaskThreadPool")
    private ThreadPoolTaskExecutor triggerTaskThreadPool;
    @Resource
    private TransactionTemplate transactionTemplate;

    /**
     * 每批大小
     */
    private static final int DEFAULT_HANDLE_DELAY_JOB_SIZE = 1;

    /**
     * 超时时间
     */
    private static final int TIMEOUT_SECOND = 120;

    @Override
    public void handleDelayJob() {
        // 查询需要触发的延时任务并将对应的任务更新到中间态
        List<TriggerTaskInfo> triggerTasks = queryTriggeredDelayedTasks();
        log.info("tasks to be scheduled {}", JacksonUtils.toJsonStr(triggerTasks));

        // 业务自定义处理器, 分发任务
        distributeTasks(triggerTasks);

        // 将任务改为最终态
        finish(triggerTasks);
        log.info("handleDelayJob success {}", JacksonUtils.toJsonStr(triggerTasks));
    }

    protected List<TriggerTaskInfo> queryTriggeredDelayedTasks() {
        // 这里可以用一些云平台的配置中心动态配置size
        return repository.queryTriggeredDelayedTasks(30);
    }

    protected void distributeTasks(List<TriggerTaskInfo> triggerTasks) {
        // 线程池每个线程调度一个任务
        PartitionUtils.partitionCall2ListAsync(triggerTasks, DEFAULT_HANDLE_DELAY_JOB_SIZE, TIMEOUT_SECOND, TimeUnit.MINUTES,
            triggerTaskThreadPool.getThreadPoolExecutor(), taskInfos -> {
                taskInfos.forEach(task -> {
                    try {
                        Class clazz = Class.forName(task.getHandler());
                        AbstractDelayJobHandler delayJobHandler = (AbstractDelayJobHandler)SpringUtil.getBean(clazz);
                        // 手工事务
                        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
                            @Override
                            protected void doInTransactionWithoutResult(TransactionStatus status) {
                                delayJobHandler.handler(task);
                            }
                        });
                    }catch (Exception e) {
                        // 失败更新为最初状态
                        log.error("handleDelayJob fail", e);
                        repository.init(task);
                    }
                });
                return Lists.newArrayList();
            });
    }

    protected abstract void handler(TriggerTaskInfo taskInfo);

    protected void finish(List<TriggerTaskInfo> triggerTask) {
        // 更新为最终状态
        repository.finish(triggerTask);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handleAbnormalDelayJob() {
        // 处理一些因为机器宕机未执行完的任务（更新时间到当前时间较久的）
        List<TriggerTaskInfo> triggerTasks = repository.queryAbnormalTasks();
        if (CollectionUtils.isEmpty(triggerTasks)) {
            return;
        }
        log.info("begin handleAbnormalDelayJob {}", JacksonUtils.toJsonStr(triggerTasks));

        // 将任务改为最初状态
        repository.init(triggerTasks);
    }

    @Override
    public void addJob(List<TriggerTaskInfo> triggerTasks) {
        repository.addJob(triggerTasks);
        log.info("addDelayJob {}", JacksonUtils.toJsonStr(triggerTasks));
    }

}

实现具体的一个handler，TriggerTaskInfo为参数类型透传每个handler，具体业务参数可以放到扩展参数json中：

@Component
public class TestDelayJob extends AbstractDelayJobHandler {

    @Override
    protected void handler(TriggerTaskInfo taskInfo) {
        // 业务逻辑
        ..........
    }
}

具体的仓储层实现，这个项目用的是mybatis，这里注意查询符合条件的任务和将任务改为中间状态是两步操作需要上事务。

接口：

public interface DelayJobScheduleService {

    /**
     * 延迟处理
     */
    void handleDelayJob();

    /**
     * 处理中断的延时任务
     */
    void handleAbnormalDelayJob();

    /**
     * 添加延时任务
     */
    void addJob(List<TriggerTaskInfo> triggerTasks);

}

实现：

@Repository
public class TriggerTaskRepositoryImpl implements TriggerTaskRepository {

    @Resource
    private TriggerTaskMapper triggerTaskMapper;

    @Override
    public void finish(List<TriggerTaskInfo> triggerTasks) {
        triggerTasks.stream().forEach(task -> task.setStatus(TriggerTaskStatusEnum.FINISH.getCode()));
        if (CollectionUtils.isEmpty(triggerTasks)) {
            return;
        }
        triggerTaskMapper.batchUpdateByPrimaryKeySelective(BeanCopierUtils.copyList(triggerTasks, TriggerTask.class));
    }

    @Override
    public void init(List<TriggerTaskInfo> triggerTasks) {
        triggerTasks.stream().forEach(task -> task.setStatus(TriggerTaskStatusEnum.INIT.getCode()));
        triggerTaskMapper.batchUpdateByPrimaryKeySelective(BeanCopierUtils.copyList(triggerTasks, TriggerTask.class));
    }

    @Override
    public void init(TriggerTaskInfo triggerTask) {
        triggerTask.setStatus(TriggerTaskStatusEnum.INIT.getCode());
        triggerTaskMapper.updateByPrimaryKey(BeanCopierUtils.copyBean(triggerTask, TriggerTask.class));
    }

    @Override
    public List<TriggerTaskInfo> queryAbnormalTasks() {
        // 查询触发任务
        Example example = new Example(TriggerTask.class);
        example.createCriteria()
            .andEqualTo("status", TriggerTaskStatusEnum.PROCESS.getCode())
            .andLessThan("updateTime", DateUtil.getDateByOffsetHours(new Date(),
                CommonConstants.NEGATIVE_ONE));
        return BeanCopierUtils.copyList(triggerTaskMapper.selectByExample(example), TriggerTaskInfo.class);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<TriggerTaskInfo> queryTriggeredDelayedTasks(Integer batchSize) {
        // 查询触发任务
        Date now = new Date();
        Example example = new Example(TriggerTask.class);
        example.createCriteria()
            .andEqualTo("status", TriggerTaskStatusEnum.INIT.getCode())
            .andEqualTo("type", TriggerTaskTypeEnum.DELAY_JOB.getCode())
            .andLessThan("triggerTime", now);
        RowBounds rowBounds = new RowBounds(CommonConstants.ZERO, batchSize);
        List<TriggerTask> triggerTasks = triggerTaskMapper.selectByExampleAndRowBounds(example, rowBounds);
        // 更新为中间状态
        triggerTasks.stream().forEach(task -> {
            task.setUpdateTime(now);
            task.setStatus(TriggerTaskStatusEnum.PROCESS.getCode());
        });
        if (CollectionUtils.isEmpty(triggerTasks)) {
            return Lists.newArrayList();
        }
        triggerTaskMapper.batchUpdateByPrimaryKeySelective(triggerTasks);
        return BeanCopierUtils.copyList(triggerTasks, TriggerTaskInfo.class);
    }

    @Override
    public void addJob(List<TriggerTaskInfo> triggerTasks) {
        if (CollectionUtils.isEmpty(triggerTasks)) {
            return;
        }
        triggerTaskMapper.insertList(BeanCopierUtils.copyList(triggerTasks, TriggerTask.class));
    }
}

最后封装一个口子给到调度服务就大功告成啦：

@Slf4j
@RestController
@RequestMapping("/delayJob")
public class DelayJobScheduleController {

    @Autowired
    private DelayJobScheduleService delayJobScheduleService;

    @ApiOperation(value = "查询并处理延时任务")
    @GetMapping(value = "/handleDelayJob")
    public void handleDelayJob() {
        delayJobScheduleService.handleDelayJob();
    }

    @ApiOperation(value = "处理异常中止的延时任务")
    @GetMapping(value = "/handleAbnormalDelayJob")
    public void handleAbnormalDelayJob() {
        delayJobScheduleService.handleAbnormalDelayJob();
    }

}

_我走路带风
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
订阅专栏
延时任务通知服务的设计及实现（三）-- JDK的延迟队列DelayQueue
天草二十六
04-29 1094
作为进程内的延迟队列，在多点部署的分布式集群环境下， 代码明显比上一篇要复杂得多。任务的生产任务的消费移除任务应用启动的时候拉取回调时间将近的未完成任务（更新marked标记为true，防止重复拉取冷数据）定时拉取未标记且回调时间将近的未完成任务（和上面必须是互斥，等待上一步执行完成，否则会导致重复拉取）删除延迟队列DelayQueue的任务，必须发布广播消息给全部节点。（引入广播消息机制）
组件设计系列：实现一个支持异步和延迟任务的线程
yishuihan的博客
11-27 292
线程是一个很简单的，今天本文将实现一种支持异步任务添加和延迟任务的线程类，开启一个线程后，可以往里面持续添加异步任务，任务串行执行，且执行顺序与添加顺序一致。支持添加延时任务。任务可以是业务方的任意函数（通过bind/function实现）。当然了，稍加改造，还可以支持定时任务的实现。同时，以本线程的实现为基础，还可以实现后续的线程池。 0、前提 首先，我们将使用到的命名空间进行封装。 1、线程类task_thread 当前的线程类，当退出线程的时候，支持三种策略。其中，THREAD_RELEASE_.
delayed_job
yangxing_star的专栏
03-26 1906
Delayed Job AUG 21ST, 2012 | COMMENTS Delayed Job 是一套非同步排程套件。 有時候，當必須執行 process time 較久的 request 時，會因為要等待此 request 執行完畢而無法再做其他的 request 導致效率低落，此時如果把 process time 較久的 request 移到背後去執行，那就可以把原本
日常开发延迟任务
m0_50601240的博客
05-02 785
日常开发延迟任务
delayed_job 的 基本用法
sg552的专栏
07-28 584
delayed_job 是用来做某些可以延后的，对时间要求不高的任务，例如： 发送1W个邮件，处理10W个数据，不能在规定的时间内（例如1秒）立即执行完的任务。 delayed_job 有两个版本，一个是最初的： [url]https://github.com/tobi/delayed_job[/url] 另一个是改进的： [url]https://github.com/collec...
delay_job_web：像Web界面一样延迟工作
02-26
延迟工作 一个启发（阅读：偷来的）接口delayed_job的。 编写该gem的目的是使用activerecord与rails 3和4应用程序一起使用。 一些功能： 轻松查看排队，工作，挂起和失败的作业。 将任何单个作业或所有待处理的作业放入队列，以立即运行。 删除失败的作业或轻松删除所有失败的作业。 通过实时ajax轮询观看delayed_job操作。 按队列名称（输入过滤器中的逗号分隔值）过滤delay_jobs。 通过单击重置按钮来重置所有队列过滤器。 界面（是的，是resque-web的翻版）： Rails 3和4应用程序快速入门 将依赖项添加到您的Gemfile gem "delayed_job_web" 安装... bundle 将以下路由添加到您的应用程序以访问界面，然后重试失败的作业。 match "/delayed_job" => Delayed
使用Redis实现延时任务的解决方案
09-09
在本文中，我们将探讨如何利用Redis来实现延时任务的解决方案。Redis是一个高效的键值存储系统，它支持多种数据结构，如字符串、列表、集合和有序集合，这使得它成为实现延时队列的理想选择。 首先，我们需要理解...
嵌入式系统中C语言实现延时程序的不同变量的区别
08-10
嵌入式系统中C语言实现延时程序的不同变量的区别 嵌入式系统中，延时是一种常用的技术手段，通过使用不同的变量类型来实现延时程序，从而影响延时的精度和效率。本文将对嵌入式系统中C语言实现延时程序的不同变量的...
基础电子中的延时电路的介绍
11-23
本文将详细介绍基础电子中的继电器延时电路，探讨其工作原理、应用场景以及调整延时时间的方法。 首先，我们要理解的是缓放缓吸电路，如图(a)所示。这种电路利用了RC（电阻-电容）网络的特性来实现延时。当电源接通...
可实现快速锁定的FPGA片内延时锁相环设计
01-19
FPGA中的DLL模块可提供零传播延时，消除时钟偏斜，从而进一步提高了FPGA的性能和设计的灵活性。 　PLL是常用的时钟管理电路，主要是基于模拟电路设计实现的，而DLL主要是基于数字电路设计实现的。虽然在时钟综合...
基础电子中的Tco和缓冲延时
11-16
本文将详细解析基础电子中的两个重要概念：Tco（Total Propagation Delay）和缓冲延时，并讨论如何计算和测量它们。 Tco，全称为总传播延迟，是衡量数字电路性能的一个重要指标。它描述的是从时钟触发时刻开始，...
使用delay-job开源项目快速实现延迟调度业务
老男孩的架构路
03-11 168
delay-job触发通知支持http、grpc、kafka，本次使用http协议通知。测试使用springboot开发了一个简易的http接口，用于接受任务触发通知。为方便，客户端、服务端部署在同一台机器。观察log/delay-job.log日志信息，确认服务正常启动，成功监听1989（http）、1990（grpc）端口。本文展示了如何借助delay-job开源项目，快速实现延迟调度业务，实现过程非常简单。手工注册一个测试任务，触发时间点为1678206771，任务触发信息通知到接口。
Laravel 延迟任务（Delayed Job）功能
weixin_34032827的博客
04-09 4867
当我们的系统触发了一个延迟任务，Laravel会用当前的时间加上任务的延迟时间计算出任务的执行时间戳，然后将这个时间戳和任务信息序列化之后存入队列，，Laravel 的队列处理器会不断查询并执行队列中满足预计执行时间等于或早于当前时间的任务。1. 创建任务我们通过 make:job 命令来创建一个任务： php artian make:job CloseOrder复制代码创建的任务类保存在 app...
延时job设计
u011381576的博客
11-23 410
一.设计初衷            目前系统系统job任务是每10分钟重试一次，总共重试7次。所有需要重试的请求都在10分钟之内堆积，如果请求量过大，这个时间点压力都有可能落到数据库上面，从而造成数据库崩溃。     此外时间配置不够智能化。如果两小时之后所依赖的第三方系统稳定，而目前的重发机制相当于失效了。 基于上面两个原因，提出了改进方案，使用延时job实现功能！ 二.功能原理    ...
延时任务调度系统——技术选型
lkl713的专栏
11-14 1017
      经常会有这样的需求，包含大量的延时执行任务 1，如一个代办事项app，代办实现可以设定触发时间，像闹钟一样。 2，如美团的订单，下单后10分钟不支付，会自动取消。 3，淘宝用户7天不确认收货，自动确认收货。 诸如以上需求，需要的就是一个延时任务执行系统。实现的方案有很多，各有优劣： 一，为每个任务创建一个倒计时线程 优点：实现简单，及时性高 缺点：严重浪费服务器CPU资源...
delay job vs resque
binbin工作室
06-30 579
How does Resque compare to DelayedJob, and why would you choose one over the other? Resque supports multiple queuesDelayedJob supports finer grained prioritiesResque workers are resilient to memory
使用Hutool的SystemTimer做延时消息处理
pywanggui的博客
02-28 1882
使用Hutool的SystemTimer做延时消息处理
Hutool_定时任务
weixin_44826433的博客
03-11 4842
前言 在写这边文章之前，也du娘过相关文章，大部分都是按照参考文档略作解释就算完了，关键点都没怎么说。。。定时任务在实际的工作当中，不可能全开全停，很多都是后台管理端有个简单的定时任务管理页面，超管可以对定时任务进行部分操作，例如：开启/关闭某个定时任务，一键开启/停止定时任务，说到这儿，前端要展示数据，后端最起码要有个任务列表数据返回吧。。。然。。。看了很多管理Hutool的相关文章，都没有这些，只是简单的介绍了怎么用，怎么开启。。。 简介 Hutool是一个小而全的Java工具类库，通过静态方法封装，降
Java中使用redis技术实现延时发布任务
最新发布
07-11
在Java中，可以使用Redis的Sorted Set（有序集合）来实现延时发布任务。下面是一个简单的示例代码： ```java import redis.clients.jedis.Jedis; import java.util.Set; public class DelayedTaskPublisher { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_我走路带风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值