JAVA 定时器框架

最新推荐文章于 2024-04-20 05:53:10 发布
最新推荐文章于 2024-04-20 05:53:10 发布
阅读量1k 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_36415076/article/details/53192672
版权

web.xml

<display-name>XXX Web Application</display-name>
<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/conf/frame-spring.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
        <context-param>
        <param-name>configLoader</param-name>
        <param-value>
            /WEB-INF/conf/frame-spring.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>

frame-spring.xml

<import resource="applicationContext-quartz.xml" />

applicationContext-quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <!--动态定时任务工厂-->
    <bean id="schedulerFactoryBean"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean" scope="singleton" >
    </bean>

    <!--Tomcat启动之后加载定时（启用）任务运行-->
    <bean id="quartzInitListener" class="com.xxx.quartz.QuartzInitListener" scope="singleton" />

</beans>

QuartzInitListener.java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

/**
 * 任务加载类
 * Tomcat启动之后自动调用处于 运行中 的任务
 */
public class QuartzInitListener implements ApplicationListener<ContextRefreshedEvent> {
    protected static final Logger LOGGER = LoggerFactory.getLogger(QuartzInitListener.class);
    @SuppressWarnings("unchecked")
    @Override
    public void onApplicationEvent(ContextRefreshedEvent ev) {
        if("0".equals(DataProcessAtom.autoTaskSwitch)){
            //关闭了定时任务，不加载任务
        }else{
            //防止重复执行。
            if(ev.getApplicationContext().getParent() == null){
                DataExchangeAssembly dataExchange = new TaskInQurartz().getDataExchage();
                ReflectionUtil.reflectThrowExceptionClearly("SXXXXXX",dataExchange,null);
            }
        }
    }
}

SXXXXXX

    /**
     * 初始化运行中的任务
     * @param dataExchange
     * @return
     */
    public GenericResult initScheduleJob2acctDataProcess(DataExchangeAssembly dataExchange){
        try {
            try {
                //获取运行中的任务
                List<ScheduleJob> jobList = getDoingJobs(dataExchange);
                for (ScheduleJob job : jobList) {
                    TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
                    //获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
                    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                    //不存在，创建一个
                    if (null == trigger) {
                        JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
                                .withIdentity(job.getJobName(), job.getJobGroup()).build();
                        jobDetail.getJobDataMap().put("scheduleJob", job);
                        //表达式调度构建器
                        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                                .getCronExpression());
                        //按新的cronExpression表达式构建一个新的trigger
                        trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
                        scheduler.scheduleJob(jobDetail, trigger);
                    } else {
                        // Trigger已存在，那么更新相应的定时设置
                        //表达式调度构建器
                        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                                .getCronExpression());
                        //按新的cronExpression表达式重新构建trigger
                        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                                .withSchedule(scheduleBuilder).build();
                        //按新的trigger重新设置job执行
                        scheduler.rescheduleJob(triggerKey, trigger);
                    }
                }
                //提示码：0；提示信息：DIA_加载运行中的任务成功
                return new AtomResult(BusinessPrompt.ATOM_SUC_CODE, BusinessPrompt.START_SCHEDULE_JOB_SUC_MSG, null);
            }catch (Exception e){
                //提示码：-100326；提示信息：DIA_开启任务失败
                throw new AtomException(BusinessPrompt.START_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.START_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
            }
        }catch (AtomException exception) {
            return new AtomResult(exception.getErrorCode(), exception.getMessage());
        }
    }

    private List<ScheduleJob> getDoingJobs(DataExchangeAssembly dataExchange) {
        Map<String, String> params = (Map<String, String>) dataExchange.getBusinessData("params");
        Map pm = new HashMap();
        pm.put("JOB_STATUS","1");
        dataExchange.setBusinessData("params",pm);
        List<ScheduleJob> ls = getJob(dataExchange);
        dataExchange.setBusinessData("params",params);
        return ls;
    }
public List<ScheduleJob> getJob(DataExchangeAssembly dataExchange) {
        //根据任务标识获取任务(从数据库中拿)
        List<Map> jobMaps = queryScheduleJob2acctDataProcess(dataExchange).getDataList();
        List<ScheduleJob> list = new ArrayList<ScheduleJob>();
        for (int i = 0,len=jobMaps.size(); i < len; i++) {
            ScheduleJob job = new ScheduleJob();
            Map jobMap = jobMaps.get(i);
            String execNo = ObjectUtils.toString(jobMap.get("EXEC_NO")).trim();
            job.setJobId(ObjectUtils.toString(jobMap.get("JOB_ID")));
            job.setJobName(ObjectUtils.toString(jobMap.get("JOB_NAME")));
            job.setJobGroup(ObjectUtils.toString(jobMap.get("JOB_GROUP")));
            job.setJobStatus(ObjectUtils.toString(jobMap.get("JOB_STATUS")));
            job.setCronExpression(ObjectUtils.toString(jobMap.get("CRON_EXPRESSION")));
            job.setDesc(ObjectUtils.toString(jobMap.get("JOB_DESC")));
            job.setExecNo(execNo);
            job.setDataExchange(dataExchange);
            job.setBusinessArea(dataExchange.getBusinessArea());
            job.setServiceArea(dataExchange.getServiceArea());
            job.setDataProcessAtom(this);
            list.add(job);
        }
        return list;
    }
    public int queryScheduleJob2acctDataProcessBiz(Map<String, String> params, Map<String, String> commParams, GenericResult result) {
        int iRetCode = 0;
        try {
            iRetCode = FrameDao.doBexCall("queryScheduleJob2acctDataProcessBex", params, commParams, result);
            if (iRetCode != FrameErrorCode.ISUCCESS_CODE) {
                //错误码：-200273；错误信息：DIA_计划任务信息查询数据操作失败。
                throw new AtomException(BusinessPrompt.QUERY_SCHEDULE_JOB_ERROR_CODE, BusinessPrompt.QUERY_SCHEDULE_JOB_ERROR_MSG, FrameworkConstants.BIZ_LVL);
            }
        } catch (AtomException exception) {
            iRetCode = exception.getErrorCode();
        }
        return iRetCode;
    }

其他任务操作

  StdScheduler scheduler =(StdScheduler)ConfigLoadUtil.applicationContext.getBean("schedulerFactoryBean");

    /**
     *  添加任务,运行
     * @param dataExchange
     */
    public void addAutoTask(DataExchangeAssembly dataExchange){
        try {
            //这里获取任务信息数据
            List<ScheduleJob> jobList = getJob(dataExchange);
            for (ScheduleJob job : jobList) {
                TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
                //获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
                CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                //不存在，创建一个
                if (null == trigger) {
                    JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
                            .withIdentity(job.getJobName(), job.getJobGroup()).build();
                    jobDetail.getJobDataMap().put("scheduleJob", job);
                    //表达式调度构建器
                    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                            .getCronExpression());
                    //按新的cronExpression表达式构建一个新的trigger
                    trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
                    scheduler.scheduleJob(jobDetail, trigger);
                } else {
                    // Trigger已存在，那么更新相应的定时设置
                    //表达式调度构建器
                    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                            .getCronExpression());
                    //按新的cronExpression表达式重新构建trigger
                    trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                            .withSchedule(scheduleBuilder).build();
                    //按新的trigger重新设置job执行
                    scheduler.rescheduleJob(triggerKey, trigger);
                }
            }
        }catch (Exception e){
            //提示码：-100326；提示信息：DIA_开启任务失败
            throw new AtomException(BusinessPrompt.START_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.START_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }


    /**
     * 删除任务(终止任务)
     * @param dataExchange
     */
    public void removeAutoTask(DataExchangeAssembly dataExchange){
        //这里获取任务信息数据
        List<ScheduleJob> jobList = getJob(dataExchange);
        try {
            for (ScheduleJob job : jobList) {
                JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
                scheduler.deleteJob(jobKey);
            }
        }catch (Exception e){
            //提示码：-100327；提示信息：DIA_恢复任务失败
            throw new AtomException(BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_MSG+"，详细信息【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }

    /**
     *  开启任务
     * @param dataExchange
     */
    public void execAutoTask(DataExchangeAssembly dataExchange) {
        removeAutoTask(dataExchange);
        addAutoTask(dataExchange);
    }

    /**
     * 恢复任务
     * @param dataExchange
     */
    public void resumeAutoTask(DataExchangeAssembly dataExchange){
        //这里获取任务信息数据
        List<ScheduleJob> jobList = getJob(dataExchange);
        try {
            for (ScheduleJob job : jobList) {
                JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
                scheduler.resumeJob(jobKey);
            }
        }catch (Exception e){
            //提示码：-100327；提示信息：DIA_恢复任务失败
            throw new AtomException(BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_MSG+"，详细信息【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }

    /**
     * 暂停任务
     * @param dataExchange
     */
    public void stopAutoTask(DataExchangeAssembly dataExchange) {
        //这里获取任务信息数据
        List<ScheduleJob> jobList = getJob(dataExchange);
        try {
            for (ScheduleJob job : jobList) {
                JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
                scheduler.pauseJob(jobKey);
            }
        }catch (Exception e){
            //提示码：-100323；提示信息：DIA_暂停任务失败
            throw new AtomException(BusinessPrompt.STOP_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.STOP_SCHEDULE_JOB_FAIL_MSG+"，详细信息【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }

    /**
     * 获取已经添加到quartz调度器的任务(计划中的任务)
     * @param dataExchange
     */
    public List<ScheduleJob> qryToDoTasks(DataExchangeAssembly dataExchange) {
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
        try {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    ScheduleJob job = new ScheduleJob();
                    job.setJobName(jobKey.getName());
                    job.setJobGroup(jobKey.getGroup());
                    job.setDesc("触发器:" + trigger.getKey());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    job.setJobStatus(triggerState.name());
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        job.setCronExpression(cronExpression);
                    }
                    jobList.add(job);
                }
            }
        }catch (Exception e){
            //提示码：-100324；提示信息：DIA_查询计划中的任务失败
            throw new AtomException(BusinessPrompt.QUERY_TODO_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.QUERY_TODO_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }finally {
            return  jobList;
        }
    }

    /**
     * 获取运行中的任务（这里的运行中是正在调用对应的接口）
     * @param dataExchange
     * @return
     */
    public List<ScheduleJob> qryDoingTasks(DataExchangeAssembly dataExchange) {
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
        try {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            jobList = new ArrayList<ScheduleJob>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                ScheduleJob job = new ScheduleJob();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                job.setJobName(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                job.setDesc("触发器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
                jobList.add(job);
            }
        }catch (Exception e){
            //提示码：-100325；提示信息：DIA_查询运行中的任务失败
            throw new AtomException(BusinessPrompt.QUERY_DOING_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.QUERY_DOING_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }finally {
            return  jobList;
        }
    }

    public GenericResult startScheduleJob2acctDataProcess(DataExchangeAssembly dataExchange) {
        try {
            if("0".equals(autoTaskSwitch)){
                throw new AtomException(BusinessPrompt.COLSED_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.COLSED_SCHEDULE_JOB_FAIL_MSG, FrameworkConstants.ATOM_LVL);
            }
            Map<String, String> params = (Map<String, String>) dataExchange.getBusinessData("params");
            Map<String, String> commParams = (Map<String, String>) dataExchange.getBusinessData("commParams");
            int iRetCode = 0;
            Uresult result = new Uresult();
            params.put("JOB_STATUS","1");
            iRetCode = dataProcessBiz.updateScheduleJob2acctDataProcessBiz(params, commParams, result);
            if (iRetCode != FrameErrorCode.ISUCCESS_CODE) {
                //提示码：-100320；提示信息：DIA_计划任务信息修改失败
                throw new AtomException(BusinessPrompt.UPDATE_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.UPDATE_SCHEDULE_JOB_FAIL_MSG, FrameworkConstants.ATOM_LVL);
            }
            execAutoTask(dataExchange);
            //提示码：0；提示信息：DIA_计划任务信息删除成功
            return new AtomResult(BusinessPrompt.ATOM_SUC_CODE, BusinessPrompt.DELETE_SCHEDULE_JOB_SUC_MSG, result.getDataList());
        } catch (AtomException exception) {
            return new AtomResult(exception.getErrorCode(), exception.getMessage());
        }
    }
行一米
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文搞懂，java中常用的定时任务框架-单体
weixin_64314555的博客
12-20 890
一、阅读收获 ✔️1. 了解常用的单体应用定时任务框架 ✔️2. 掌握定时任务在单体中如何使用 二、Timer+TimerTask 这是jdk自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。 使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行,一般用的较少。 /** * @Description: 1. Timer+TimerTask：（jdk自带） * 这是java自带的java.util.Timer类，这个类允许..
java 定时器
xlnjulp Stay Hungry, Stay Foolish
08-04 564
定时任务是我们在做项目的时候经常使用到的，比如定时发送心跳，定时请求数据等等。无论是使用开源的定时任务框架Quartz等，还是使用JDK原生态的定时任务都可以很好的完成这个任务。碰巧最近看源码看到了有的地方使用到了javax.management.timer.Timer，所以在这里记录下JDK中提供的几种定时任务的使用方法，权当做总结了~1、javax.management.timer.Timer对
Java定时任务及常见框架
weixin_45734473的博客
10-08 2268
Java定时任务及常见框架
java定时任务框架有哪些
weixin_35755562的博客
12-27 1000
Java有许多定时任务框架可供选择。常见的定时任务框架有： Quartz：强大的定时任务框架，支持多种调度策略和集群部署。 Timer和TimerTask：Java自带的定时任务框架，使用简单但功能有限。 Spring Task：Spring框架的定时任务模块，使用简单，支持注解配置。 cron4j：一个基于cron表达式的定时任务框架。 java.util.concurrent包中的S...
Java定时任务调度框架
热门推荐
靖节先生的博客
04-14 1万+
Java定时任务调度框架1. 定时任务调度概述1.1 业务场景概述1.2 任务调度场景1.3 调度任务分类2. 定时任务调度详解2.1 Timer2.2 ScheduledExecutorService2.3 SpringTask2.4 Quartz2.5 xxl-job2.6 elastic-job 1. 定时任务调度概述 1.1 业务场景概述 日常开发中定时任务使用场景很多，比如支付系统每天凌晨定时清算对账；未支付订单超时回收；商品定时上下架等等。定时任务框架选择有很多，面对不同的业务场景可以选择不同的
Java定时任务框架整理
AVATAR
12-30 6066
再见 Spring Task，这个定时任务框架真香！ 目录 再见 Spring Task，这个定时任务框架真香！ 为什么需要定时任务？ 单机定时任务技术选型 Timer ScheduledExecutorService Spring Task 时间轮 分布式定时任务技术选型 Quartz Elastic-Job XXL-JOB PowerJob 总结 以下文章来源于JavaGuide，作者Guide哥 JavaGuide. 专注Java后端学习和大厂面试的公众号！开源.
Java定时器
Mr.Xie的博客
06-06 730
1、使用线程睡眠方法控制，每间隔2000毫秒执行一次 final long time=2000;//2秒一次 Runnable runnable=new Runnable() { @Override public void run() { while(true){ System.out.println("Hello World"); try { ...
Java定时器框架(Quartz)
12-23
Java定时器框架Quartz是Java开发中用于任务调度的一个强大工具，它允许开发者精确地控制任务的执行时间，包括一次性任务和周期性任务。Quartz以其灵活性和稳定性，在企业级应用中广泛使用，尤其在需要定期执行后台...
java定时器设置及停止的方法
06-17
如果你在Spring框架中工作，还可以利用Spring的定时任务支持，如Quartz或Spring Task。Quartz是一个强大且高度可配置的调度器，它可以按指定时间或频率执行任务。在Spring中使用Quartz，你需要创建一个作业类（Job）...
Java定时器Timer简述
08-31
Java定时器Timer是Java语言中用于执行定时任务的类，它位于`java.util`包下。Timer类提供了在指定时间或周期性执行任务的能力，但需要注意的是，它并不保证任务的实时执行，也就是说，任务的实际执行时间可能会受到...
java 定时任务管理框架
09-06
可以通过少量修改直接融入到已有的java项目，有维护定时器的界面，包括新增修改删除，立即执行，暂停，恢复等功能，省去了项目中大量配置定时器的繁琐,而且便于维护
定时任务框架
11-02
使用springboot搭建的一个定时任务框架,具有增,删,改,查,启动,暂停任务的功能,前端页面使用react+antd搭建,详细介绍: https://blog.csdn.net/qq_35488769/article/details/83628374
JAVA定时器JAVA定时器.pdf
10-08
JAVA定时器是一种基于Quartz框架的任务调度器，用于在指定的时间执行特定的任务。在 Spring 框架中，JAVA定时器可以与Quartz框架集成，实现自动执行任务的功能。 1. JAVA定时器的基本概念 JAVA定时器是基于Quartz...
Java定时器.pdf
10-08
Java定时器框架主要由`java.util.Timer`和`java.util.TimerTask`组成，这两个类提供了在Java中安排一次性或重复性任务的能力。然而，这个框架存在一定的局限性，例如无法直接处理夏令时变化导致的时间跳跃问题，对于...
一文搞懂，java中常用的定时任务框架-单体，2024Java大厂面试经验分享
m0_60635176的博客
03-28 893
Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！Java面试核心知识点[外链图片转存中…(img-oVEuzlt1-1711601057504)][外链图片转存中…(img-pd84iQwv-1711601057505)]由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新。
一文搞懂java中的定时任务框架-分布式(xxl-job)
最新发布
2301_82243396的博客
04-20 910
com.xuxuelixxl-job-core${project.parent.version}复制代码4.2 修改配置文件：xxl-job-executor-sample-springboot/src/main/resources/application.properties修改调度中心部署跟地址需修改或自定义xxl.job.admin.addresses 地址xxl.job.executor.appname 自定义名称，后台配置必须对应xxl.job.executor.ip 当前电脑Ip，或部署项目的电
java常见的三种定时任务调度框架，写得太棒了
Cr1556648487的博客
08-12 2955
CronTrigger实现Trigger的nextExecutionTime方法，根据定时任务执行的上下文环境(最近调度时间和最近完成时间)决定查找下一次执行时间的左边界，之后调用CronSequenceGenerator的next方法从左边界开始找下一次的执行时间。槽的内部用双向链表存储着待执行的任务，添加和删除链表的操作时间复杂度为O（1），槽位本身也指代时间精度，比如一秒扫一个槽，那么这个时间轮的最高精度就是1秒。因此一般情况下，用于移动指针的线程只负责任务的触发，任务的执行交由其他的线程来完成。..
java常见的三种定时任务调度框架介绍
h123_58的博客
01-29 1532
java常见的三种定时任务调度框架介绍
Java 定时任务--Quartz框架
Dora的专栏
08-09 1778
Quartz是一个定时任务调度框架，可以将其理解为一个闹钟，可以设置在具体的某个时间，同样可以设置是否按某种规则循环。
Java 定时器框架，可视化，可查看错误及异常信息 有没有推荐的
07-11
对于Java定时器框架，我可以向您推荐Quartz。Quartz是一个功能强大且广泛使用的开源定时任务调度框架，它允许您创建基于时间的作业并在预定时间执行它们。Quartz提供了丰富的功能，包括可视化管理界面和错误/异常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值