一文学会线程池、任务调度的使用

  private ExecutorService executorService = Executors.newFixedThreadPool(5); // 初始化线程池线程数量
  
  public void testExecutorService() {
      // 线程任务
      Runnable task = new Runnable() {
          @Override
          public void run() {
              log.debug("HELLO ExecutorService");
          }
      };
      for (int i = 0; i < 10; i++) {
          executorService.submit(task); // 多次执行
      }
      sleep(10); // 防止线程终止
  }

    /**
     * JDK可执行定时任务的线程池
     */
    private ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

	public void testScheduleExecutorService() {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                log.debug("HELLO ScheduleExecutorService");
            }
        };
        // 需要执行的任务，第一次延迟多久执行，每个多久执行一次，时间单位
        scheduledExecutorService.scheduleAtFixedRate(task, 1, 1, TimeUnit.SECONDS);
        sleep(10);
    }

    @Resource
    private ThreadPoolTaskExecutor taskExecutor;

	public void testThreadPoolTaskExecutor() {
        // 需要执行的任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                log.debug("HELLO ThreadPoolTaskExecutor");
            }
        };
        for (int i = 0; i < 10; i++) {
            taskExecutor.submit(task);
        }
        sleep(10);
    }

      // Spring定时任务线程池
      @Resource
      private ThreadPoolTaskScheduler taskScheduler;
  	@Test
  	public void testThreadPoolTaskScheduler() {
          Runnable task = new Runnable() {
              @Override
              public void run() {
                  log.debug("HELLO ThreadPoolTaskScheduler");
              }
          };
          // 需要执行的任务，隔多久执行一次
          taskScheduler.scheduleAtFixedRate(task, 2000);
          sleep(10);
  	}

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

@Slf4j
public class AlphaJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.warn(Thread.currentThread().getName()+": execute a quartz job.");
    }
}

/**
 * 启动项目，将配置信息初始化到数据库中，之后直接访问数据库，
 * 数据库可以被每个实例所获取，从而实现了分布式定时任务
 *
 * @author : look-word
 * 2022-11-13 20:11
 **/
@Configuration
public class QuartzConfig {
    // 配置JobDetail(任务)
    @Bean
    public JobDetailFactoryBean alphaJobDetail() {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        factoryBean.setJobClass(AlphaJob.class); // 需要被执行的任务
        factoryBean.setName("alphaJob");
        factoryBean.setGroup("alphaJobGroup");
        factoryBean.setDurability(true); // 是否持久化到数据库
        factoryBean.setRequestsRecovery(true); // 当出现问题，是否可恢复
        return factoryBean;
    }

    // 配置 Trigger(触发器)
    @Bean
    public SimpleTriggerFactoryBean alphaTrigger(JobDetail alphaJobDetail) {
        SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
        factoryBean.setJobDetail(alphaJobDetail);
        factoryBean.setName("alphaTrigger");
        factoryBean.setGroup("alphaTriggerGroup");
        factoryBean.setRepeatInterval(3000); // 间隔多久执行
        factoryBean.setJobDataMap(new JobDataMap());
        return factoryBean;
    }
}

# quartz 分布式定时任务
spring:
  quartz:
    job-store-type: jdbc
    scheduler-name: communityScheduler
    properties:
      org:
        quartz:
          scheduler:
            instanceId: AUTO  #调度器id自动生成
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX                      # 完成Job持久化配置的类
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate   # 存储使用的JDBC
            isClustered: true                                                   # 是否以集群的方式
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool                            # 使用的线程类
            threadCount: 5														# 线程池的数量

@Resource
private Scheduler scheduler;

@Test
public void testDeleteJob() throws SchedulerException {
    System.out.println(scheduler.deleteJob(new JobKey("alphaJob", "alphaJobGroup")));
}