定时任务实现方式

实现定时任务有5种方式：

  1. 使用线程创建定时任务
  2. 使用 TimerTask 创建定时任务
  3. 使用线程池创建定时任务
  4. 使用 Quartz 框架实现定时任务
  5. 使用 @Scheduled 注解实现定时任务
  6. xxl-job 实现分布式定时任务

一、使用线程创建定时任务

public class ThreadTask {

    public static class Demo01 {
        static long count = 0;

        public static void main(String[] args) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            Thread.sleep(1000);
                            count++;
                            System.out.println(count);
                        } catch (Exception e) {
                            // TODO: handle exception
                        }
                    }
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
}

 

二、使用TimerTask创建定时任务

public class Timer4Task {

    static long count = 0;
    public static void main(String[] args) {
        TimerTask timer4Task = new TimerTask() {
            @Override
            public void run() {
                count++;
                System.out.println(count);
            }
        };
        //创建timer对象设置间隔时间
        Timer timer = new Timer();
        // 间隔天数
        long delay = 0;
        // 间隔毫秒数
        long period = 1000;
        timer.scheduleAtFixedRate(timer4Task, delay, period);
    }
}

 

 

三、使用线程池创建定时任务

public class ThreadPoolTask {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // task to run goes here
                System.out.println("Hello !!");
            }
        };
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
        service.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);
    }
}


四、使用Quartz框架实现定时任务

public class QuartzTask {

    public static void main(String[] args) throws SchedulerException {
        //1.创建Scheduler的工厂
        SchedulerFactory sf = new StdSchedulerFactory();
        //2.从工厂中获取调度器实例
        Scheduler scheduler = sf.getScheduler();
        //3.创建JobDetail，
        JobDetail jb = JobBuilder.newJob(SelfJob.class)
                //job的描述
                .withDescription("this is a ram job")
                //job 的name和group
                .withIdentity("ramJob", "ramGroup")
                .build();
        //任务运行的时间，SimpleSchedle类型触发器有效，3秒后启动任务
        long time = System.currentTimeMillis() + 3 * 1000L;
        Date statTime = new Date(time);
        //4.创建Trigger
        //使用SimpleScheduleBuilder或者CronScheduleBuilder
        Trigger t = TriggerBuilder.newTrigger()
                .withDescription("")
                .withIdentity("ramTrigger", "ramTriggerGroup")
                //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
                //默认当前时间启动
                .startAt(statTime)
                //两秒执行一次，Quartz表达式，支持各种牛逼表达式
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
                .build();
        //5.注册任务和定时器
        scheduler.scheduleJob(jb, t);
        //6.启动 调度器
        scheduler.start();
    }
}
————————————————
/**
 * 继承Quartz框架中的Job，并重写execute方法
 */
public class SelfJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("quartz Job date:" + System.currentTimeMillis());
    }
}

 

五、使用 @Scheduled 注解实现定时任务

@Configuration // 这里使用@Component也行
public class ScheduleTask {

    //添加定时任务-- 50分钟执行一次
    @Scheduled(fixedRate = 50 * 60 * 1000)
    private void updateTask() {
        Console.log("@Scheduled 注解实现定时任务 执行-------------------");
    }
}

启动类增加 @EnableScheduling 注解，启动服务。


六、使用 xxl-job 实现分布式定时任务

<dependency>
     <groupId>com.xuxueli</groupId>
     <artifactId>xxl-job-core</artifactId>
     <version>2.2.0</version>
 </dependency>       
————————————————
xxl:
  job:
    accessToken:
    executor:
      appname: demo
      ip:
      logpath: /data/applogs/xxl-job/jobhandler
      logretentiondays: -1
      port: 9966
    admin:
#      addresses: http://127.0.0.1:8089/xxl-job-admin
      addresses: http://49.234.28.149:8086/xxl-job-admin
————————————————
@Component
@Slf4j
@RequiredArgsConstructor
public class XxlJobHandler{

    @XxlJob("demoHandler")
    public ReturnT<Object> run (Object s) throws Exception {
        XxlJobLogger.log("xxl-job测试任务开始执行。【args: {}】", s);
        try {
            System.out.println("执行一次xxl-job打印任务！");
            XxlJobLogger.log("xxl-job测试任务执行结束。");
            return null;
        } catch (Exception e) {
            XxlJobLogger.log("xxl-job测试任务执行出错!", e);
            return null;
        }
    }
}
————————————————
@JobHandler(value="demoHandler")
@Component
public class DemoJobHandler extends IJobHandler {

     static int count;
    @Override
    public ReturnT<String> execute(String param) throws Exception {
        System.out.println("执行job任务"+count++);
        return SUCCESS;
    }
}
————————————————

 

6.4 下载并启动 xxl-job
下载地址：https://github.com/xuxueli/xxl-job/

找到 xxl-job-admin 模块，初始化数据库并配置数据库资源、端口等，最后启动服务。

启动后在浏览器输入： http://localhost:8061/xxl-job-admin ，进入 xxl-job 管理后台：

添加好执行器，再新建一个任务：

启动服务后会每5秒执行一次，可以根据需求自定义执行时间和周期。

————————————————

 

多机部署之定时任务完整方案

1.场景描述

老项目需要多机部署，项目中有几十个定时任务，一旦多机部署，定时任务就会重复执行，固定ip与错开时间方案都存在较大弊端，最终采用的方案是:AOP+排他锁的方式，软件老王已验证通过，介绍下，有需要的朋友可以参考下。

2.解决方案

软件老王基本方案是采用：AOP+排他锁的方式。

（1）目前老项目有几十个定时任务，采用AOP的方式，可以保证代码的无侵入（即使简单的微侵入，例如增加几行代码，测试验证的工作量也会比较大的）。
（2）采用排他锁的方式，保证批处理的高可用，不重复执行。

2.1 AOP编程

Aop的概念就不说了，就是面向切面编程，通俗点就是统一处理一类问题，比如日志、请求鉴权等，刚开始不确定是否可行，系统中的批处理是使用spring注解的方式@Scheduled进行批处理，采用aop对注解@Scheduled进行编程，统一拦截批处理，代码如下：

/**
 * 软件老王-AOP处理类
 */
@Aspect
@Component
public class ScheduledAspect {
    @Autowired
    ScheduleService scheduleService ;

    @Pointcut( "@annotation(org.springframework.scheduling.annotation.Scheduled)")
    public void scheduled() {
    }
    @Around("scheduled()")
    public Object scheduled(ProceedingJoinPoint pjd) {
        Object result = null;
        String taskName = pjd.getSignature().getName();
        try {
            if (scheduleService.isInvoke(taskName)){
                return result;
            }
            result = pjd.proceed();
            scheduleService.end(taskName);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return result;
    }
}

说明：

（1）面向标签编程

  @Pointcut( "@annotation(org.springframework.scheduling.annotation.Scheduled)")

这样注解会拦截标签@Scheduled。

（2）使用aop的环绕标签 @Around("scheduled()")

@before标签拿不到执行完成状态，需要使用环绕标签@@Around，在标签中可以拿到执行完成后状态，以便放开锁。

 result = pjd.proceed();

（3）结合排他锁使用

   @Autowired
    ScheduleService scheduleService ;

2.2 排他锁

排他锁，简单来说就是通过数据库总的标志位+版版号进行的控制.

软件老王的代码如下，：

/**
 * 软件老王-排他锁服务类
 */
@Service
public class ScheduleService {
    @Autowired
    ScheduleClusterMapper scheduleClusterMapper;

    public boolean isInvoke(String taskName) {
        boolean isValid = false;
        try {
            ScheduleCluster carIndexEntity = scheduleClusterMapper.selectByTaskName(taskName);
            int execute = carIndexEntity.getExecute();
            String ip = InetAddress.getLocalHost().getHostAddress();
            long currentTimeMillis = System.currentTimeMillis();
            long time = carIndexEntity.getUpdatedate().getTime();
            if (execute == 0) {
                isValid = start(taskName, carIndexEntity.getVersion(), ip);
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        return isValid;
    }
    //执行锁机制，软件老王
    public boolean start(String taskName, int version, String ip) {
        ScheduleCluster scheduleCluster = new ScheduleCluster();
        scheduleCluster.setVersion(version);
        scheduleCluster.setExecuteIp(ip);
        scheduleCluster.setUpdatedate(DateUtil.getCurrentTime());
        scheduleCluster.setTaskName(taskName);
        scheduleCluster.setExecute(1);
        int count = scheduleClusterMapper.updateByTaskName(scheduleCluster);
        if (count > 0) {
            return true;
        }
        return false;
    }
    //执行解锁机制，软件老王
    public void end(String taskName) {
        ScheduleCluster scheduleCluster = new ScheduleCluster();
        scheduleCluster.setUpdatedate(DateUtil.getCurrentTime());
        scheduleCluster.setTaskName(taskName);
        scheduleCluster.setExecute(0);
        scheduleClusterMapper.updateNormalByTaskName(scheduleCluster);
    }
}

说明：

大的原理是在where条件后带上版本号，在update中更新version+1，这样通过影响数据库的影响条数，来判断是否拿到锁。

（1）主类中调用start方法，该方法是更新批处理状态，软件老王这里设置了一个小点，在updateByTaskName的mybatis方法中，有个version+1的更新；

（2）end方法放在更新完成后，释放锁。

（3）其实还有一个点，可以考虑下，需要有个机制，比如出现异常情况，刚好批处理执行中，重启服务了等，下次批处理执行前，假如锁还未释放，代码中增加释放锁的机制。

2.3 数据库相关

（1）数据库表设计

（2）mybatis相关方法

（1）第一个是start对应方法，执行锁和version增加。

 <update id="updateByTaskName" parameterType="com.yutong.dmp.entity.ScheduleCluster">
    update t_schedule_cluster
    <set>
        <if test="executeIp != null">
            execute_ip = #{executeIp,jdbcType=VARCHAR},
        </if>
        <if test="version != null">
            version = #{version,jdbcType=INTEGER} + 1,
        </if>
        <if test="execute != null">
            execute = #{execute,jdbcType=INTEGER},
        </if>
        <if test="status != null">
            status = #{status,jdbcType=VARCHAR},
        </if>
        <if test="createby != null">
            createby = #{createby,jdbcType=VARCHAR},
        </if>
        <if test="createdate != null">
            createdate = #{createdate,jdbcType=TIMESTAMP},
        </if>
        <if test="updateby != null">
            updateby = #{updateby,jdbcType=VARCHAR},
        </if>
        <if test="updatedate != null">
            updatedate = #{updatedate,jdbcType=TIMESTAMP},
        </if>
    </set>
    where task_name = #{taskName,jdbcType=VARCHAR}
    and version = #{version,jdbcType=INTEGER}
    and status ='1'
  </update>

（2）第二个是释放锁，更改excute为0。

<update id="updateNormalByTaskName" parameterType="com.yutong.dmp.entity.ScheduleCluster">
    update t_schedule_cluster
    <set>
        <if test="executeIp != null">
            execute_ip = #{executeIp,jdbcType=VARCHAR},
        </if>
        <if test="version != null">
            version = #{version,jdbcType=INTEGER},
        </if>
        <if test="execute != null">
            execute = #{execute,jdbcType=INTEGER},
        </if>
        <if test="status != null">
            status = #{status,jdbcType=VARCHAR},
        </if>
        <if test="createby != null">
            createby = #{createby,jdbcType=VARCHAR},
        </if>
        <if test="createdate != null">
            createdate = #{createdate,jdbcType=TIMESTAMP},
        </if>
        <if test="updateby != null">
            updateby = #{updateby,jdbcType=VARCHAR},
        </if>
        <if test="updatedate != null">
            updatedate = #{updatedate,jdbcType=TIMESTAMP},
        </if>
    </set>
    where task_name = #{taskName,jdbcType=VARCHAR}
    and status ='1'
</update>

 

1、Oracle

思路：Insert表内容时，主键重复，无法插入

范围：适用于执行频率低的定时任务

方法：新建一张任务执行表，每次执行定时任务之前先insert该表。

比如：每天执行一次批处理操作。主键可以设置为批处理name+日期（年月日）。集群服务器可能会同时去insert该表，而只有一台服务器能插入成功，则只让这一台服务器执行该批处理任务。

 

2、Redis

范围：适用于执行频率高的定时任务

有如下两种思路方法：

思路1：采用的是redis中list的push和pop操作。因为Redis是单线程，所有命令依次执行，所以不会出现多台服务器同时访问的情况。

方法：系统初始化时，向Redis中lpush一个list(key,1)，作为标识Flag。每台服务器执行批处理之前,先去rpop该list，只有获取到该标识的服务器才能执行批处理任务，执行完毕后再lpush回一个list(key,1)。

比如：执行任务前先执行rpopRedisFlag，任务完成后执行lpushRedisFlag.

public class AutoJobActDis extends QuartzJobBean {

@Override
protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
if (rpopRedisFlag("AUTO_JOB_ACTDIS")) {
this.executeJob(this);
lpushRedisFlag("AUTO_JOB_ACTDIS");
}
}
/**
* 从缓存中取得Flag，获取定时任务执行权限
*
* @param redisKey
* @return
*/
public boolean rpopRedisFlag(String redisKey) {
String redisValue = redisService.rpopRedisList(redisKey);
if (StringUtil.isEmpty(redisValue)) {
return false;
} else {
return true;
}
}

 

 

/**
* 缓存中增加Flag
*
* @param redisKey
*/
public void lpushRedisFlag(String redisKey) {
redisService.lpushRedisList(redisKey, "1");
}
｝

public class RedisService {
/**
* 存储Redis队列，顺序存储
* @param key redis键名
* @param value 键值
*/
public void lpushRedisList(String key, String value) {
Jedis jedis = null;
try {
jedis = jedisClient.getClient();
jedis.lpush(key, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
} finally {
if (jedis != null) {
jedis.close();
}
}
}

/**
* 移除并获取列表最后一个元素
* @param key
* @return
*/
public String rpopRedisList(String key) {
Jedis jedis = null;
try {
jedis = jedisClient.getClient();
return jedis.rpop(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
} finally {
if (jedis != null) {
jedis.close();
}
}
return null;
}
｝


思路2：采用的是redis中String的incr和expire操作。因为Redis是单线程，所有命令依次执行，所以不会出现多台服务器同时访问的情况。

语法：INCR key  将 key 中储存的数字值增一。

    Redis Incr 命令将 key 中储存的数字值增一。

    如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。

    如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。

    本操作的值限制在 64 位(bit)有符号数字表示之内。

EXPIRE key seconds  为给定 key 设置过期时间。

    Redis Expire 命令用于设置 key 的过期时间。key 过期后将不再可用。

方法：每台服务器执行批处理之前,先去incr一个固定key，只有返回值等于1的服务器才能执行批处理任务，然后将该key值设置过期时间。

比如：

jedis = jedisTool.getJedis();
if(jedis.incr(PRE_AGAIN_REDIS+batchId)!=1) {
logger.info("其他机器已经重跑");
return ;
} else {
jedis.expire(PRE_AGAIN_REDIS+batchId, 60);//设置60s过期
}

 

posted @ 2021-03-11 00:24  hanease  阅读(555)  评论(0)    收藏  举报