【SpringBoot】调度和执行定时任务--Quartz(超详细)

Quartz 是一个功能强大的任务调度框架，广泛用于在 Java 应用程序中定时执行任务，同时它支持 Cron 表达式、持久化任务、集群等特性。以下是 Quartz 的详细使用教程，包括安装、基本概念、简单示例和高级功能。

1. 安装 Quartz

首先，在你的项目中添加 Quartz 依赖。对于 Maven 项目，可以在 pom.xml 中添加以下依赖：

<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.3.2</version>
</dependency>

对于 Gradle 项目，可以在 build.gradle 中添加以下依赖：

implementation 'org.quartz-scheduler:quartz:2.3.2'

2. 基本概念

Quartz 的核心概念包括：

  • Scheduler：调度器，是 Quartz 的核心，负责管理和调度任务。
  • Job：任务，是实际执行的工作单元。需要实现 Job 接口。
  • JobDetail：定义任务的详细信息，包括任务的名称、组、以及任务的类。
  • Trigger：触发器，定义任务何时执行。常用的触发器包括 SimpleTrigger 和 CronTrigger。
  • JobStore：任务存储，定义任务的存储方式。常见的有 RAMJobStore（内存存储）和 JDBCJobStore（数据库存储）。

3. 简单示例

以下是一个简单的 Quartz 示例，展示如何创建和调度一个任务。

1. 定义 Job 类

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;public class HelloJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Hello, Quartz! Current time: " + System.currentTimeMillis());}
}

2. 配置 Scheduler 和 Job

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class QuartzExample {public static void main(String[] args) throws SchedulerException {// 创建 Scheduler 实例Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();// 定义一个 JobDetail 实例JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("helloJob", "group1").build();// 创建一个触发器，每隔5秒执行一次Trigger trigger = TriggerBuilder.newTrigger().withIdentity("helloTrigger", "group1").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever()).build();// 调度任务scheduler.start();scheduler.scheduleJob(job, trigger);}
}

4. 高级功能

1. 使用 CronTrigger

CronTrigger 允许使用 Cron 表达式来定义复杂的调度规则。

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class CronTriggerExample {public static void main(String[] args) throws SchedulerException {Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("cronJob", "group1").build();// 使用 Cron 表达式创建触发器Trigger trigger = TriggerBuilder.newTrigger().withIdentity("cronTrigger", "group1").withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?")).build();scheduler.start();scheduler.scheduleJob(job, trigger);}
}

2. Cron 表达式

Cron 表达式用于定义任务调度的时间规则。它由6或7个字段组成，字段之间用空格分隔。以下是每个字段的含义：

┌───────────── 秒 (0 - 59)
│ ┌───────────── 分 (0 - 59)
│ │ ┌───────────── 小时 (0 - 23)
│ │ │ ┌───────────── 日 (1 - 31)
│ │ │ │ ┌───────────── 月 (1 - 12)
│ │ │ │ │ ┌───────────── 星期几 (0 - 7) (0 和 7 都是星期日)
│ │ │ │ │ │
│ │ │ │ │ │
* * * * * *

2.1 特殊字符

  • *: 表示任意值。
  • ?: 仅在日和星期字段中使用，表示不指定值。
  • -: 表示范围，例如 10-12 表示从10到12。
  • ,: 表示列表值，例如 1,2,3 表示1、2、3。
  • /: 表示增量，例如 0/15 表示从0开始每15分钟。
  • L: 表示最后，例如 L 在日字段表示月的最后一天。
  • W: 表示最近的工作日，例如 15W 表示最接近15号的工作日。
  • #: 表示第几个星期几，例如 2#1 表示第一个星期一。

2.2 示例

  • 0 0 12 * * ?: 每天中午12点执行。
  • 0 15 10 ? * *: 每天上午10:15执行。
  • 0 15 10 * * ?: 每天上午10:15执行。
  • 0 15 10 * * ? 2024: 2024年每天上午10:15执行。
  • 0 * 14 * * ?: 每天下午2点到2:59每分钟执行一次。
  • 0 0/5 14 * * ?: 每天下午2点到2:55每5分钟执行一次。
  • 0 0/5 14,18 * * ?: 每天下午2点到2:55每5分钟执行一次，以及每天下午6点到6:55每5分钟执行一次。
  • 0 0-5 14 * * ?: 每天下午2点到2:05每分钟执行一次。
  • 0 10,44 14 ? 3 WED: 每年三月的每个星期三下午2:10和2:44执行。

3. 使用 JobListener

JobListener 可以在任务执行的不同阶段进行拦截和处理。

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;public class MyJobListener implements JobListener {@Overridepublic String getName() {return "MyJobListener";}@Overridepublic void jobToBeExecuted(JobExecutionContext context) {//在任务即将被执行时调用，可以在任务执行前进行一些准备工作或记录日志。System.out.println("Job is about to be executed: " + context.getJobDetail().getKey());}@Overridepublic void jobExecutionVetoed(JobExecutionContext context) {//在任务执行被否决时调用，当某些条件满足时，可以阻止任务的执行，并在此方法中执行相应的处理逻辑。System.out.println("Job execution was vetoed: " + context.getJobDetail().getKey());}@Overridepublic void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {//在任务执行完成后调用，可以在任务执行后进行一些清理工作或记录日志。如果任务执行过程中抛出异常，jobException 将包含该异常信息。System.out.println("Job was executed: " + context.getJobDetail().getKey());if (jobException != null) {System.out.println("Job encountered an exception: " + jobException.getMessage());}}
}

在 Scheduler 中注册 JobListener：

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class JobListenerExample {public static void main(String[] args) throws SchedulerException {Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();//创建任务JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("listenerJob", "group1").build();创建触发器Trigger trigger = TriggerBuilder.newTrigger().withIdentity("listenerTrigger", "group1").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever()).build();// 创建并注册 JobListenerMyJobListener listener = new MyJobListener();scheduler.getListenerManager().addJobListener(listener);scheduler.start();scheduler.scheduleJob(job, trigger);}
}

5. 持久化支持

Quartz 支持将任务数据持久化到数据库中，以便在系统重启后恢复任务状态。可以使用 JDBCJobStore 来实现这一点。

在 quartz.properties 文件中配置 JDBCJobStore：

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.dataSource = myDS
org.quartz.jobStore.tablePrefix = QRTZ_org.quartz.dataSource.myDS.driver = com.mysql.cj.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/quartz
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = password
org.quartz.dataSource.myDS.maxConnections = 5

6. 并发控制

在 Quartz 中，默认情况下，任务是并发执行的。如果需要确保同一个任务实例不被并发执行，可以实现 DisallowConcurrentExecution 接口。为了清楚地展示 DisallowConcurrentExecution 注解的作用，我们可以创建两个示例：一个使用 DisallowConcurrentExecution 注解，另一个不使用该注解。通过这两个示例，我们可以观察到任务在并发执行方面的差异。

示例 1：不使用 DisallowConcurrentExecution

在这个示例中，我们创建一个简单的任务类，它会模拟一个长时间运行的任务，并且不使用 DisallowConcurrentExecution 注解。

1. 定义 Job 类

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;public class ConcurrentJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("ConcurrentJob is executing at: " + System.currentTimeMillis());try {// 模拟长时间运行的任务Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("ConcurrentJob finished at: " + System.currentTimeMillis());}
}

2. 配置 Scheduler 和 Job

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class ConcurrentJobExample {public static void main(String[] args) throws SchedulerException {Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();JobDetail job = JobBuilder.newJob(ConcurrentJob.class).withIdentity("concurrentJob", "group1").build();// 创建一个触发器，每隔2秒执行一次Trigger trigger = TriggerBuilder.newTrigger().withIdentity("concurrentTrigger", "group1").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever()).build();scheduler.start();scheduler.scheduleJob(job, trigger);}
}

示例 2：使用 DisallowConcurrentExecution

在这个示例中，我们创建一个类似的任务类，但这次使用 DisallowConcurrentExecution 注解，确保任务不会并发执行。

1. 定义 Job 类

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;@DisallowConcurrentExecution
public class NonConcurrentJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("NonConcurrentJob is executing at: " + System.currentTimeMillis());try {// 模拟长时间运行的任务Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("NonConcurrentJob finished at: " + System.currentTimeMillis());}
}

2. 配置 Scheduler 和 Job

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class NonConcurrentJobExample {public static void main(String[] args) throws SchedulerException {Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();JobDetail job = JobBuilder.newJob(NonConcurrentJob.class).withIdentity("nonConcurrentJob", "group1").build();// 创建一个触发器，每隔2秒执行一次Trigger trigger = TriggerBuilder.newTrigger().withIdentity("nonConcurrentTrigger", "group1").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever()).build();scheduler.start();scheduler.scheduleJob(job, trigger);}
}

运行示例

当你运行这两个示例时，你会看到以下行为：

不使用 DisallowConcurrentExecution 的输出

ConcurrentJob is executing at: 1633017600000
ConcurrentJob is executing at: 1633017602000
ConcurrentJob finished at: 1633017605000
ConcurrentJob is executing at: 1633017604000
ConcurrentJob finished at: 1633017607000
ConcurrentJob finished at: 1633017609000

可以看到，任务是并发执行的，多个任务实例同时运行。

使用 DisallowConcurrentExecution 的输出

NonConcurrentJob is executing at: 1633017600000
NonConcurrentJob finished at: 1633017605000
NonConcurrentJob is executing at: 1633017605000
NonConcurrentJob finished at: 1633017610000
NonConcurrentJob is executing at: 1633017610000
NonConcurrentJob finished at: 1633017615000

可以看到，任务是顺序执行的，新的任务实例只有在前一个实例完成后才会开始执行。

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;@DisallowConcurrentExecution
public class NonConcurrentJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Non-concurrent job is executing at: " + System.currentTimeMillis());}
}

通过这两个示例，我们可以清楚地看到 DisallowConcurrentExecution 注解的作用：它确保同一个任务实例不会并发执行，而是顺序执行。这在某些需要严格控制任务执行顺序的场景中非常有用。

7. 任务依赖管理

Quartz 本身并不直接支持任务依赖管理（即任务之间的依赖关系），但可以通过编程方式实现这一功能。通常的方法是使用多个 Job 和 Trigger，并在 Job 执行完成后手动调度下一个依赖的 Job。

1. 异步任务依赖管理

Quartz 本身并不直接支持任务依赖管理（即任务之间的依赖关系），但可以通过编程方式实现这一功能。通常的方法是使用多个 Job 和 Trigger，并在 Job 执行完成后手动调度下一个依赖的 Job。

以下是一个示例，展示如何在 Quartz 中实现任务依赖管理：

示例场景

假设有三个任务：

  1. 任务 A：完成后触发任务 B。
  2. 任务 B：完成后触发任务 C。
  3. 任务 C：最后执行。

实现步骤

  1. 定义三个 Job 类。
  2. 配置 Scheduler 和 Job。
  3. 在每个 Job 中执行完成后手动调度下一个依赖的 Job。

代码示例

1. 定义 Job 类
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;public class JobA implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Job A executed at: " + System.currentTimeMillis());// 获取 Scheduler 实例Scheduler scheduler = context.getScheduler();try {// 创建 JobB 的 JobDetailJobDetail jobB = JobBuilder.newJob(JobB.class).withIdentity("jobB", "group1").build();// 创建立即触发的 TriggerTrigger triggerB = TriggerBuilder.newTrigger().withIdentity("triggerB", "group1").startNow().build();// 调度 JobBscheduler.scheduleJob(jobB, triggerB);} catch (SchedulerException e) {throw new JobExecutionException(e);}}
}public class JobB implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Job B executed at: " + System.currentTimeMillis());// 获取 Scheduler 实例Scheduler scheduler = context.getScheduler();try {// 创建 JobC 的 JobDetailJobDetail jobC = JobBuilder.newJob(JobC.class).withIdentity("jobC", "group1").build();// 创建立即触发的 TriggerTrigger triggerC = TriggerBuilder.newTrigger().withIdentity("triggerC", "group1").startNow().build();// 调度 JobCscheduler.scheduleJob(jobC, triggerC);} catch (SchedulerException e) {throw new JobExecutionException(e);}}
}public class JobC implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Job C executed at: " + System.currentTimeMillis());}
}
2. 配置 Scheduler 和 Job
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class QuartzDependencyExample {public static void main(String[] args) throws SchedulerException {// 创建 Scheduler 实例Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();// 定义 JobAJobDetail jobA = JobBuilder.newJob(JobA.class).withIdentity("jobA", "group1").build();// 创建立即触发的 TriggerTrigger triggerA = TriggerBuilder.newTrigger().withIdentity("triggerA", "group1").startNow().build();// 调度 JobAscheduler.start();scheduler.scheduleJob(jobA, triggerA);}
}

解释

  1. JobA：在执行完成后，手动调度 JobB。
  2. JobB：在执行完成后，手动调度 JobC。
  3. JobC：最后执行，没有后续任务。

通过这种方式，可以实现任务之间的依赖关系。在每个任务执行完成后，手动调度下一个依赖的任务。这样，即使 Quartz 本身不直接支持任务依赖管理，也可以通过编程方式实现这一功能。

注意事项

  1. 异常处理：确保在调度下一个任务时正确处理异常，防止由于调度失败导致任务链中断。
  2. 并发控制：如果有多个任务链，需要确保并发控制，防止多个任务同时调度同一个任务。
  3. 持久化支持：如果任务链较长或需要持久化，确保使用持久化的 Scheduler 配置，以便在系统重启后恢复任务状态。

2. 同步任务依赖管理

在上面的示例中，任务之间的调度是异步的。每个 Job 在执行完成后，会立即调度下一个 Job，但不会等待下一个 Job 的执行完成。这种方式适用于大多数场景，但如果需要同步执行（即一个任务必须等待前一个任务执行完成后再执行），则需要一些额外的机制来确保任务的同步执行。

为了实现同步的任务依赖管理，可以使用以下方法：

  1. 使用 JobListener：监听每个任务的执行完成事件，并在事件触发时调度下一个任务。
  2. 使用共享的状态或信号量：在任务之间共享状态或使用信号量来确保任务按顺序执行。

以下是一个使用 JobListener 实现同步任务依赖管理的示例：

实现步骤

  1. 定义三个 Job 类。
  2. 实现 JobListener接口。
  3. 配置 Scheduler 和 Job。
  4. 当触发jobWasExecuted后调度下一个依赖的 Job。

示例代码

1. 定义 Job 类
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;public class JobA implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Job A executed at: " + System.currentTimeMillis());}
}public class JobB implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Job B executed at: " + System.currentTimeMillis());}
}public class JobC implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Job C executed at: " + System.currentTimeMillis());}
}
2. 定义 JobListener
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.quartz.SchedulerException;public class DependencyJobListener implements JobListener {private Scheduler scheduler;public DependencyJobListener(Scheduler scheduler) {this.scheduler = scheduler;}@Overridepublic String getName() {return "DependencyJobListener";}@Overridepublic void jobToBeExecuted(JobExecutionContext context) {// No action needed before job execution}@Overridepublic void jobExecutionVetoed(JobExecutionContext context) {// No action needed if job execution is vetoed}@Overridepublic void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {String jobName = context.getJobDetail().getKey().getName();try {if ("jobA".equals(jobName)) {// 调度 JobBJobDetail jobB = JobBuilder.newJob(JobB.class).withIdentity("jobB", "group1").build();Trigger triggerB = TriggerBuilder.newTrigger().withIdentity("triggerB", "group1").startNow().build();scheduler.scheduleJob(jobB, triggerB);} else if ("jobB".equals(jobName)) {// 调度 JobCJobDetail jobC = JobBuilder.newJob(JobC.class).withIdentity("jobC", "group1").build();Trigger triggerC = TriggerBuilder.newTrigger().withIdentity("triggerC", "group1").startNow().build();scheduler.scheduleJob(jobC, triggerC);}} catch (SchedulerException e) {e.printStackTrace();}}
}
3. 配置 Scheduler 和 Job
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class QuartzDependencyExample {public static void main(String[] args) throws SchedulerException {// 创建 Scheduler 实例Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();// 定义 JobAJobDetail jobA = JobBuilder.newJob(JobA.class).withIdentity("jobA", "group1").build();// 创建立即触发的 TriggerTrigger triggerA = TriggerBuilder.newTrigger().withIdentity("triggerA", "group1").startNow().build();// 添加 JobListenerscheduler.getListenerManager().addJobListener(new DependencyJobListener(scheduler));// 调度 JobAscheduler.start();scheduler.scheduleJob(jobA, triggerA);}
}

解释

  1. JobA、JobB、JobC：分别定义三个独立的 Job 类。
  2. DependencyJobListener：实现 JobListener 接口，在每个 Job 执行完成后，根据当前执行的 Job 调度下一个 Job。
  3. Scheduler 配置：在 Scheduler 中注册 DependencyJobListener，并调度初始的 JobA。

注意事项

  1. 异常处理：确保在调度下一个任务时正确处理异常，防止由于调度失败导致任务链中断。
  2. 并发控制：如果有多个任务链，需要确保并发控制，防止多个任务同时调度同一个任务。
  3. 持久化支持：如果任务链较长或需要持久化，确保使用持久化的 Scheduler 配置，以便在系统重启后恢复任务状态。

3. 任务拦截

在 Quartz 中，可以通过实现 JobListener 来拦截任务的执行。JobListener 提供了几个方法，可以在任务执行前、执行后以及任务被否决时进行拦截和处理。

下面是一个详细的示例代码，展示如何使用 JobListener 来拦截任务的执行，并附有详细注释。

示例代码

1. 定义 Job 类
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;// 定义一个简单的 Job 类
public class SampleJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("SampleJob is executing at: " + System.currentTimeMillis());}
}
2. 实现 JobListener
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;// 实现 JobListener 接口
public class MyJobListener implements JobListener {@Overridepublic String getName() {// 返回监听器的名称return "MyJobListener";}@Overridepublic void jobToBeExecuted(JobExecutionContext context) {// 在任务即将执行时调用System.out.println("Job is about to be executed: " + context.getJobDetail().getKey());}@Overridepublic void jobExecutionVetoed(JobExecutionContext context) {// 在任务被否决时调用System.out.println("Job execution was vetoed: " + context.getJobDetail().getKey());}@Overridepublic void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {// 在任务执行完成后调用System.out.println("Job was executed: " + context.getJobDetail().getKey());if (jobException != null) {System.out.println("Job encountered an exception: " + jobException.getMessage());}}
}
3. 配置 Scheduler 和 Job
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;public class QuartzJobListenerExample {public static void main(String[] args) throws SchedulerException {// 创建 Scheduler 实例Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();// 定义一个 JobDetail 实例JobDetail job = JobBuilder.newJob(SampleJob.class).withIdentity("sampleJob", "group1").build();// 创建一个触发器Trigger trigger = TriggerBuilder.newTrigger().withIdentity("sampleTrigger", "group1").startNow().build();// 创建并注册 JobListenerMyJobListener listener = new MyJobListener();scheduler.getListenerManager().addJobListener(listener);// 调度任务scheduler.start();scheduler.scheduleJob(job, trigger);}
}

解释

  1. SampleJob：定义一个简单的 Job 类，包含一个 execute 方法，打印当前时间。
  2. MyJobListener：实现 JobListener 接口，提供四个方法：
    • getName：返回监听器的名称。
    • jobToBeExecuted：在任务即将执行时调用，打印任务的 Key。
    • jobExecutionVetoed：在任务被否决时调用，打印任务的 Key。
    • jobWasExecuted：在任务执行完成后调用，打印任务的 Key 和异常信息（如果有）。
  3. QuartzJobListenerExample：主类，配置 Scheduler 和 Job：
    • 创建 Scheduler 实例。
    • 定义一个 JobDetail 实例。
    • 创建一个触发器。
    • 创建并注册 JobListener 实例。
    • 调度任务并启动 Scheduler。

注意事项

  1. 异常处理：在 jobWasExecuted 方法中处理任务执行中的异常，确保异常信息被记录或处理。
  2. 并发控制：如果有多个任务并发执行，需要确保监听器的实现是线程安全的。
  3. 持久化支持：在需要持久化任务状态时，确保 Scheduler 配置支持持久化。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/54447.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

京东广告投放平台整洁架构演进之路

京东广告投放平台整洁架构演进之路

作者&#xff1a;广告研发 赵嘉铎 前言 从去年开始京东广告投放系统做了一次以领域驱动设计为思想内核的架构升级&#xff0c;在深入理解DDD思想的同时&#xff0c;我们基于广告投放业务的本质特征大胆地融入了自己的理解和改造。新架构是从设计思想到落地框架都进行了彻底的…
阅读更多...
Python 解析 Charles JSON Session File (.chlsj)

Python 解析 Charles JSON Session File (.chlsj)

Charles 代理&#xff0c;是一款抓包软件&#xff0c;可以帮助我们抓取浏览器请求跟响应。 1、在 Filter 里面输入需要抓包的网址 2、右键 Export Session 3、文件类型选择 JSON Session File (.chlsj) 保存 4、解析响应的数据结构 response.body.text 是文本字符串。 # 导入…
阅读更多...
自然语言处理-基于注意力机制的文本匹配

自然语言处理-基于注意力机制的文本匹配

背景&#xff1a; 任务三&#xff1a;基于注意力机制的文本匹配 输入两个句子判断&#xff0c;判断它们之间的关系。参考ESIM&#xff08;可以只用LSTM&#xff0c;忽略Tree-LSTM&#xff09;&#xff0c;用双向的注意力机制实现。 参考 《神经网络与深度学习》 第7章 Reaso…
阅读更多...
SpringCloud微服务消息驱动的实践指南

SpringCloud微服务消息驱动的实践指南

Spring Cloud是一个用于构建分布式系统的开发工具&#xff0c;通过它可以快速搭建基于微服务架构的应用&#xff0c;并提供了丰富的功能和解决方案。在Spring Cloud中&#xff0c;消息驱动是一种常见的通信模式&#xff0c;通过消息传递来实现不同微服务之间的数据交互。本文将…
阅读更多...
【移动端开发】“明日头条APP”

【移动端开发】“明日头条APP”

文章目录 1 系统概述1.1研究背景1.2研究意义 2 系统设计2.1 关键技术2.2 系统设计2.2.1 系统功能模块2.2.2 数据库设计 3 系统实现3.1 数据模型3.1.1 NewsURL3.1.2 NewsType3.1.3 NewsInfo 3.2 数据库操作3.2.1 DBOpenHelper3.2.2 DBManager 3.3 适配器类3.3.1 AddItem3.3.2 In…
阅读更多...
LabVIEW机械产品几何精度质检系统

LabVIEW机械产品几何精度质检系统

随着制造业的发展&#xff0c;对产品质量的要求越来越高&#xff0c;机械产品的几何精度成为衡量其品质的重要指标。为了提高检测效率和精度&#xff0c;开发了一套基于LabVIEW的几何精度质检系统&#xff0c;该系统不仅可以自动化地进行几何尺寸的测量&#xff0c;而且能实时分…
阅读更多...
Qt 边框border - qss样式

Qt 边框border - qss样式

border属性 实际上&#xff0c;border并不是一个单独的属性&#xff0c;在Qt样式表中&#xff0c;它通常指的是一系列与边框相关的属性的组合。然而&#xff0c;你也可以在一条样式规则中一次性设置所有这些值&#xff0c;如下所示&#xff1a; QPushButton { border: 2px sol…
阅读更多...
smardaten无代码这么牛逼？逻辑编排不用代码！

smardaten无代码这么牛逼？逻辑编排不用代码！

目录 前言 经典案例 ①计划编排&#xff1a;数据操作自动化 ②工单派工&#xff1a;流程变更自动化 smardaten能力解析 一、逻辑控制篇 &#xff08;1&#xff09;变量定义与操作 &#xff08;2&#xff09;数据校验与反馈 &#xff08;3&#xff09;动态数据获取与回填…
阅读更多...
演示：基于WPF自绘的中国省份、城市、区县矢量地图

演示：基于WPF自绘的中国省份、城市、区县矢量地图

一、目的&#xff1a;演示一个基于WPF自绘的中国省份、城市、区县矢量地图 二、效果 国 省 市 三、功能 支持实际经纬度显示 支持平移&#xff0c;缩放等功能 显示中国地图 显示各个省份地图 显示各个省份地图&#xff08;包含在表格中&#xff0c;包含缩率图&#xff09; 显…
阅读更多...
Android Studio报错： Could not find pub.devrel:easypermissions:0.3.0， 改用linux编译

Android Studio报错： Could not find pub.devrel:easypermissions:0.3.0， 改用linux编译

在Android studio中去编译开源的仓库&#xff0c;大概率就是各种编译不过&#xff0c;一堆错误&#xff0c;一顿改错&#xff0c;基本上会耗费非常多时间&#xff0c;比如&#xff1a; 这个就是改gradle版本&#xff0c;改成7.2 &#xff0c;修改完成之后&#xff0c;还有其他报…
阅读更多...
rabbitmq容器化部署

rabbitmq容器化部署

目录 需求 容器化部署rabbitmq服务 部署服务 验证及访问服务 rabbitmq配置LTS 服务验证 rabbitmq配置集群 部署集群 1、创建一个存放配置文件的目录 2、创建配置文件 3、部署各个节点 集群验证 需求 容器化部署rabbitmq服务 基础版本 系统ubuntu 24&#xff0c;docke…
阅读更多...
Java后端框架---Spring

Java后端框架---Spring

目录 一.Spring是什么&#xff1f; 二.Spring Hello World 搭建 三.XML配置bean管理 1.bean标签 2.依赖注入 3.依赖注入的补充 四.注解配置bean管理 1.开启注解扫描 2.使用注解对类进行配置 3.自动注入 五.面向切面编程AOP 1.概述 2.通知 六.spring事务管理 1.数据库…
阅读更多...
【踩坑】装了显卡，如何让显示器从主板和显卡HDMI都输出

【踩坑】装了显卡，如何让显示器从主板和显卡HDMI都输出

转载请注明出处&#xff1a;小锋学长生活大爆炸[xfxuezhagn.cn] 如果本文帮助到了你&#xff0c;欢迎[点赞、收藏、关注]哦~ 背景介绍 装了显卡后&#xff0c;开机默认是从显卡的HDMI输出&#xff0c;但这很不方便。如何让视频仍然从主板输出&#xff1f;或者说让显卡HDMI和主板…
阅读更多...
系统 IO

系统 IO

"裸奔"层次&#xff1a;不带操作系统的编程 APP(应用程序) -------------------------------- Hardware(硬件) 特点&#xff1a;简单&#xff0c;应用程序直接操作硬件(寄存器) 缺点&#xff1a; 1. 搞应用开发的必须要了解硬件的实现细节&#xff0c;能够看懂原理图…
阅读更多...
LeetCode_sql_day24（1212.查询球队积分）

LeetCode_sql_day24（1212.查询球队积分）

描述 表: Teams ------------------------- | Column Name | Type | ------------------------- | team_id | int | | team_name | varchar | ------------------------- team_id 是该表具有唯一值的列。 表中的每一行都代表一支独立足球队。表: Matches…
阅读更多...
【笔记】2.1 半导体三极管（BJT，Bipolar Junction Transistor）

【笔记】2.1 半导体三极管（BJT，Bipolar Junction Transistor）

一、结构和符号 1. 三极管结构 常用的三极管的结构有硅平面管和锗合金管两种类型。各有PNP型和NPN型两种结构。 左图是NPN型硅平面三极管，右图是PNP型锗合金三极管。 从图中可见平面型三极管是先在一块大的金属板上注入杂质使之变成N型，然后再在中间注入杂质使之变成P型，…
阅读更多...
Note091203_Outlook邮件撤回操作

Note091203_Outlook邮件撤回操作

Note091203_Outlook邮件撤回操作 如图所示&#xff1a; step1: 打开outlook step2&#xff1a; 点击已发送邮件&#xff0c;选中目标撤回邮件双击打开&#xff1b; step3&#xff1a; 点击图中2框所示&#xff0c;可看见撤回操作&#xff1b; 以上
阅读更多...
Linux操作系统 进程(3)

Linux操作系统 进程(3)

接上文 Linux进程优先级之后&#xff0c;我们了解到僵尸进程与孤儿进程的形成原因&#xff0c;既然是因为父进程没有接收子进程的退出状态导致的&#xff0c;那么我们该如何去获取子进程的退出状态呢&#xff1f;那本篇文章将围绕这个问题来解释进程。 环境 &#xff1a; vsco…
阅读更多...
基于CNN的10种物体识别项目

基于CNN的10种物体识别项目

一&#xff1a;数据导入和处理 1.导入相关包&#xff1a; import numpy as np import pandas as pd import matplotlib.pyplot as plt import tensorflow as tf2.下载数据 (x_train_all, y_train_all), (x_test, y_test) tf.keras.datasets.cifar10.load_data()# x_valid:测…
阅读更多...
【Qt笔记】QTabWidget控件详解

【Qt笔记】QTabWidget控件详解

目录 引言 一、基本功能 二、核心属性 2.1 标签页管理 2.2 标签位置 2.3 标签形状 2.4 标签可关闭性 2.5 标签可移动性 三、信号与槽 四、高级功能 4.1 动态添加和删除标签页 4.2 自定义标签页的关闭按钮行为 4.3 标签页的上下文菜单 五、样式设置 六、应用示例…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023