springboot+java+多线程自动化定时任务

1.引入定时任务对应的maven

	org.springframework.boot
	spring-boot-starter-quartz


	org.quartz-scheduler
	quartz
	2.2.1
	jar

2.在application启动类添加开启定时任务的注解

![在这里插入图片描述](https://img-blog.csdnimg.cn/e7c56d5da923481eaf810a4c919b1bdf.png

@EnableScheduling

3.配置自动化任务，使用多线程动态执行不同的定时任务

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.xuanwu.bingo.base.voToGs;
import com.xuanwu.bingo.constant.CommonConstant;
import com.xuanwu.bingo.redis.client.PranaRedisClient;
import com.xuanwu.bingo.util.RedisHashUtils;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.CronTask;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledFuture;


@Log4j2
@Component
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    PranaRedisClient pranaRedisClient;
    @Autowired
    RedisHashUtils redisHashUtils;


    private volatile ScheduledTaskRegistrar registrar;

    private final ConcurrentHashMap> scheduledFutures = new ConcurrentHashMap<>();

    private final ConcurrentHashMap cronTasks = new ConcurrentHashMap<>();

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        //设定一个长度10的定时任务线程池，根据需要自己设置长度
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(500));
        this.registrar = taskRegistrar;
    }

    @PreDestroy
    public void destroy() {
        this.registrar.destroy();
    }
	  
    public void refreshTask( String cron, String taskId) {
        if (StringUtils.isEmpty(cron)) {
            return;
        }
        //判断同一任务id和cron表达式，不在重复执行
        if (scheduledFutures.containsKey(taskId) && cronTasks.get(taskId).getExpression().equals(cron)) {
            return;
        }
        //判断不同cron同一taskid，删除之前执行的任务，执行新的任务
        if (scheduledFutures.containsKey(taskId)) {
            scheduledFutures.get(taskId).cancel(false);
            scheduledFutures.remove(taskId);
            cronTasks.remove(taskId);
        }
        CronTask task = new CronTask(new Runnable() {
          	//此处可以定义一些线程里面使用的动态变量，方便run里面调用，每个线程之间是互不影响独立调用的
            @Override
            public void run() {
                //执行业务逻辑
                try {
                   //执行自己的定时任务，方法可以写出去

                } catch (Exception e) {
                    log.info("执行任务异常，异常信息：" + e);
                }
            }
        }, cron);
        ScheduledFuture future = registrar.getScheduler().schedule(task.getRunnable(), task.getTrigger());
        cronTasks.put(taskId, task);
        scheduledFutures.put(taskId, future);
    }
    
    public void deleteTask(String taskId) {
        scheduledFutures.keySet().forEach(key -> {
            if (Objects.equals(key, taskId)) {
                scheduledFutures.get(key).cancel(false);
                scheduledFutures.remove(key);
                cronTasks.remove(key);
                return;
            }
        });

    }
}

4.调用就很方便，直接springboot实例化类对象调用方法就行了

    @Autowired
    ScheduleConfig scheduleConfig;

 scheduleConfig.refreshTask('cron表达式','任务id');