Java-定时器(内置-自定义(普通,分布式)可以切换)

短命女 2023-10-02 17:58 3阅读 0赞

### 使用Timer和TimerTask存在一些缺陷： ###

1.Timer只创建了一个线程。当你的任务执行的时间超过设置的延时时间将会产生一些问题。  
2.Timer创建的线程没有处理异常，因此一旦抛出非受检异常，该线程会立即终止。  
3.Timer使用的是绝对时间，即是某个时间点，所以它执行依赖系统的时间，如果系统时间修改了的话，将导致任务可能不会被执行。

**Timer和TimerTask的使用(简单演示)**

Timer  timer = new Timer();
         //2000表示第一次执行任务延迟时间，40表示以后每隔多长时间执行一次run里面的任
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    log.e("time:");
    
                }
            }, 2000, 40);务

### ScheduledThreadPoolExecutor(周期无限) ###

基于线程池的定时器,比Timer好多了

package com.timer;
    
    import com.function.impl.ExecutorUtils;
    import org.springframework.lang.NonNull;
    
    import java.util.Map;
    import java.util.Timer;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ScheduledThreadPoolExecutor;
    import java.util.concurrent.ThreadFactory;
    import java.util.concurrent.TimeUnit;
    
    //java内置定时器
    public class ScheduledThreadPoolExecutorUtils {
        
    
        private  ScheduledThreadPoolExecutor scheduledThreadPoolExecutor;
    
        private ScheduledThreadPoolExecutorUtils(ScheduledThreadPoolExecutor scheduledThreadPoolExecutor) {
        
            this.scheduledThreadPoolExecutor = scheduledThreadPoolExecutor;
        }
    
        private static class InitializeThreadFactory implements ThreadFactory {
        
    
           @Override
           public Thread newThread(@NonNull  Runnable r) {
        
               //可以在创建线程时候进行其他的处理,比如线程名称
               return new Thread(r);
           }
       }
       public static ScheduledThreadPoolExecutorUtils build() {
        
           return  new ScheduledThreadPoolExecutorUtils(new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors()*2,new InitializeThreadFactory()));
       }
    
        /**
         * 延迟并以固定周期时间循环执行命令
         * @param command 任务     scheduleAtFixedRate不会计算任务本身的时间(推荐)。 scheduleWithFixedDelay的实际执行周期为延迟时间delay+任务执行时间。
         * @param initialDelay  延迟时间
         * @param period  周期
         * @param unit  时间单位
         */
       public   void scheduleAtFixedRate(Runnable command,
                                  long initialDelay,
                                  long period,
                                  TimeUnit unit) {
        
           scheduledThreadPoolExecutor.scheduleAtFixedRate(command,initialDelay,period,unit);
    
       }
    
        /**
         *  周期时间循环执行命令
         * @param command 任务
         * @param delay 周期
         * @param unit 时间单位
         */
        public   void  schedule(Runnable command,
                           long delay, TimeUnit unit) {
        
            scheduledThreadPoolExecutor.schedule(command,delay,unit);
        }
    
    
    }

**测试类**

package com.timer;
    
    import java.io.Serializable;
    
    public class TimerRunnableTest implements Runnable, Serializable  {
        
        private static final long serialVersionUID = 1L;
        @Override
        public void run() {
        
    
            System.out.println("-----TimerRunnableTest-----");
    
    
        }
    
    }

执行测试类

@Test
        public void show1() throws InterruptedException {
        
           TimerRunnableTest TimerRunnableTest=new TimerRunnableTest();
           try {
        
               CustomTimerUtils.creadTimer("show1",TimerRunnableTest,"2022-02-18 09:21:00","0/9 * * * * ?",6);
           } catch (Exception e) {
        
               e.printStackTrace();
           }
           Thread.sleep(1000000);
       }

### 自定义定时器 ###

java内置的定时器基本都有点缺陷,很多场景不能灵活运用,那么我们何不自己写一个定时器呢?  
写定时器前我们需要了解定时器的规则

1.  时间钟 (寻找到时间的定时器)
2.  cron 定时器执行时间
3.  count (定时器执行的次数,不设置那么就循环执行)
4.  定时器延迟执行 (就是定时器在之后的某个时间点才开始执行)
5.  保证多台服务器,定时器的一致性(一个项目部署到多台服务器,同一时间相同定时器只有一个生效)
6.  定时器增删改查, (改查可以没有)
7.  JDBC事物(用于分布式定时器,当然也可以使用redis来解决)

**mysql表**

CREATE TABLE `t_timer_list` (
      `key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
      `obj` blob,
      PRIMARY KEY (`key`),
      KEY `key` (`key`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

#### CustomTimerUtils ####

package com.timer;
    
    import com.commonutils.CronUtils;
    import com.commonutils.SleepTools;
    import com.date.DataEnum;
    import com.date.LocalDateUtils;
    import com.function.impl.ExecutorUtils;
    import com.jdbctemplate.ConnectionPond;
    import com.jdbctemplate.JdbcUtils;
    import com.obj.serializable.SerializeUtil;
    import org.apache.commons.lang.StringUtils;
    
    import java.time.LocalDateTime;
    import java.util.Date;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * huanmin
     * 个人定制版定时器
     * 单机定时:     需要将lock设置为false (不依赖)
     * 分布式定时器:  需要将lock设置为true  (依赖mysql数据库)
     */
    public class CustomTimerUtils {
        
    
        //分布式锁 默认不开启false  ,如果设置为true那么必须配置数据库
        private static boolean lock = true;
    
        //定时器线程池
        private static Map<String, TimerObj> map = new ConcurrentHashMap<>();
    
        //开启一个主线程,扫描线程池中是否有需要执行的线程
        static {
        
    
            monitoring1(); //启动时间钟
    
        }
    
        private static void monitoring1() {
        
            ExecutorUtils.newThreadDaemon(() -> {
        
                while (true) {
        
                    if (lock) {
        
                        startMysql();
                    } else {
        
                        for (Map.Entry<String, TimerObj> stringTimerObjEntry : map.entrySet()) {
        
                            TimerObj timerObj = stringTimerObjEntry.getValue();
                            start(timerObj);
                        }
    
                    }
                    SleepTools.second(1);
                }
            });
        }
    
        private static void startMysql() {
        
    
            //分布式锁的方式 (开启事物)
            TimerTransactionPessimism timerTransactionPessimism = new TimerTransactionPessimism();
            JdbcUtils.transaction(timerTransactionPessimism, "timer");
        }
    
        public static void start(TimerObj timerObj) {
        
    
            //当前时间
            LocalDateTime localDateTime = LocalDateUtils.dateLocalDateTime(new Date());
            String local = LocalDateUtils.format(localDateTime, DataEnum.UNSIGNED_DATETIME_PATTERN.getValue());
            if (!timerObj.getStart().get()) {
         //未启动定时器
                //如果启动时间是null那么就立即执行周期启动
                if (StringUtils.isBlank(timerObj.getStartTime()) && !timerObj.getStart().get()) {
        
                    timerObj.getStart().set(true); //将定时任务改为启动状态
                    //修改数据库数据
                    updateTimer(timerObj);
                }
                //判断起始时间不能为空,并且定时器未启动,并且起始时间小于或者等于当前时间
                if (!StringUtils.isBlank(timerObj.getStartTime()) && !timerObj.getStart().get() && Long.parseLong(local) >= Long.parseLong(timerObj.getStartTime())) {
        
                    //启动线程一次
                    ExecutorUtils.create("CustomTimerUtils+monitoring1", 50, timerObj.getRunnable());
                    timerObj.getStart().set(true); //将定时任务改为启动状态
                    timerObj.setStartTime(null);//清除起始时间
                    adjust(timerObj);
                }
            } else {
        //已启动定时器
    
                if (timerObj.getStart().get() && Long.parseLong(local) >= Long.parseLong(timerObj.getTime())) {
        
                    //启动线程一次
                    ExecutorUtils.create("CustomTimerUtils+monitoring2", 200, timerObj.getRunnable());
    
                    //计算下次执行时间
                    timerObj.setTime();
                    //测试定时器--------
                    System.out.println(timerObj);
                    adjust(timerObj);
                }
            }
    
        }
    
        //处理数据
        public static void adjust(TimerObj timerObj) {
        
            if (timerObj.getCount() != null && timerObj.getCount().get() > 0) {
        
                if (timerObj.getCount().decrementAndGet() <= 0) {
        
                    //删除死亡的定时器
                    removeTimer(timerObj.getKey());
                }
            }
            //修改数据库数据
            updateTimer(timerObj);
        }
    
    
        //修改数据
        public static void updateTimer(TimerObj timerObj) {
        
            //修改数据库数据
            if (lock) {
        
                byte[] serialize = SerializeUtil.serialize(timerObj);
                ConnectionPond timer = JdbcUtils.getConnectionPond("timer");
                JdbcUtils.execute(timer, "UPDATE `t_timer_list` SET `obj` = ?   WHERE `key` = ?", serialize, timerObj.getKey());
    
            }
        }
    
        //删除死亡的定时器
        public static void removeTimer(String key) {
        
            if (lock) {
        
                //从数据库中删除
                ConnectionPond timer = JdbcUtils.getConnectionPond("timer");
                JdbcUtils.execute(timer, "delete from t_timer_list WHERE `key`= ?", key);
            } else {
        
                //从当前列表中删除
                map.remove(key);
            }
        }
    
    
        /**
         * 从指定时间开始执行 ,然后周期进行执行 ,并且执行指定次数(起始也算在内)
         *
         * @param key       定时任务名称,必须唯一,否则就会覆盖
         * @param runnable  任务
         * @param startTime yyyy-MM-dd HH:mm:ss   起始时间如果为空立即执行cron周期
         * @param cron      0 1 * * * ?     周期时间
         * @param count     执行次数  为null一直执行  否则执行指定次数
         */
        public static void creadTimer(String key, Runnable runnable, String startTime, String cron, Integer count) throws Exception {
        
    
            if (lock) {
        
                TimerObj timerObj = new TimerObj(key, runnable, startTime, cron, count);
                System.out.println(timerObj);
                byte[] serialize = SerializeUtil.serialize(timerObj);
    
                Map<String, Object> query = JdbcUtils.query("select count(1) as count from t_timer_list where `key`=? ", key);
                if ((Long)query.get("count")<=0) {
        
                    //存入数据库 ,如果有此定时器那么就跳过,利用主键冲突
                    JdbcUtils.execute("insert into t_timer_list (`key`,`obj`) VALUES(?,?)", key, serialize);
                }
            } else {
        
                //存入当前内存中
                CronUtils.crinVerif(cron);
                TimerObj timerObj = new TimerObj(key, runnable, startTime, cron, count);
                map.put(timerObj.getKey(), timerObj);
            }
    
    
        }
    
        //周期进行执行
        public static void creadTimer(String key, Runnable runnable, String cron) throws Exception {
        
            creadTimer(key, runnable, null, cron, null);
    
        }
    
        //周期进行执行,执行指定次数
        public static void creadTimer(String key, Runnable runnable, String cron, Integer count) throws Exception {
        
            creadTimer(key, runnable, null, cron, count);
    
        }
    
        //从指定时间开始执行 ,然后周期进行执行 ,
        public static void creadTimer(String key, Runnable runnable, String startTime, String cron) throws Exception {
        
            creadTimer(key, runnable, startTime, cron, null);
        }
    
    
    }

#### TimerObj ####

package com.timer;
    
    
    import com.commonutils.CronUtils;
    import com.date.LocalDateUtils;
    import lombok.Data;
    
    import java.io.Serializable;
    import java.util.concurrent.atomic.AtomicBoolean;
    import java.util.concurrent.atomic.AtomicInteger;
    @Data
    public  class TimerObj  implements Serializable {
        
        private static final long serialVersionUID = 1L;
        private String key;  //定时任务名称
        private Runnable runnable;  //需要运行的线程
        private String startTime;   // startTime时候开始执行一次,然后每隔time执行一次
        private AtomicBoolean start;  // 是否启动定时器 默认是false
        private AtomicBoolean end;  // 定时器结束 默认是false
        private String time; //下次执行的时间 循环执行  yyyy-MM-dd HH:mm:ss
        private String cron;
        private AtomicInteger count; //执行次数
    
        public TimerObj(String key, Runnable runnable, String strTime, String cron, Integer count) {
        
            this.runnable = runnable;
            if (strTime != null) {
        
                this.startTime = transitionTime(strTime);
            }
            this.cron = cron;
            ;
            this.start = new AtomicBoolean(false);
            if (count != null) {
        
                this.count = new AtomicInteger(count);
            }
            //设置唯一key
            this.key = key;
            //计算下次执行时间
            setTime();
    
        }
    
        //时间转换
        public String transitionTime(String strTime) {
        
            return LocalDateUtils.datetimePatternTransitionUnsignedDatetimePattern(strTime);
        }
    
        //下次执行的时
        public void setTime() {
        
            this.time = CronUtils.resolverCron(cron);
        }
    
    }

#### TimerTransactionPessimism ####

package com.timer;
    
    import com.jdbctemplate.JdbTransaction;
    import com.jdbctemplate.JdbcUtils;
    import com.obj.serializable.SerializeUtil;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.List;
    import java.util.Map;
    
    public class TimerTransactionPessimism implements JdbTransaction {
        
    
        @Override
        public void run(Connection connection) throws Exception {
        
            //从数据库中查全部定时器  (事物加锁方式,悲观锁不可重复加锁)
                PreparedStatement preparedStatement = connection.prepareStatement("select* from  t_timer_list for update");
                ResultSet resultSet = preparedStatement.executeQuery();
                List<Map<String, Object>> maps = JdbcUtils.dataGroup(resultSet);
                for (Map<String, Object> map : maps) {
        
                    TimerObj obj = SerializeUtil.unserialize((byte[]) map.get("obj"), TimerObj.class);
                    CustomTimerUtils.start(obj);//处理中
                }
        }
    
    }

#### 自定义定时器spring方式 ####

在自定义的基础上,补充了注解+spring监听器的方式

**类注解CustomTimer**

package com.timer.spring;
    
    import org.springframework.stereotype.Component;
    
    import java.lang.annotation.*;
    
    @Documented
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Component
    public @interface CustomTimer {
        
    }

**方法注解CustomTimerCron**

package com.timer.spring;
    
    import java.lang.annotation.*;
    
    @Documented
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface CustomTimerCron {
        
    
        String startTime()default ""; //启动时间 startTime时候,开始执行一次,然后每隔time执行一次   ""==null
        String  cron(); //cron表达式 (周期执行)
        int  count() default -1; //执行次数  -1==null
    }

**执行方法类SpringTimerRunnable**

package com.timer.spring;
    
    import java.io.Serializable;
    import java.lang.reflect.Method;
    
    public class SpringTimerRunnable implements Runnable, Serializable {
        
        private static final long serialVersionUID = 1L;
        private Class aClass;
        private String key;
    
        public SpringTimerRunnable(Class aClass, String key) {
        
            this.aClass = aClass;
            this.key = key;
        }
    
        @Override
        public void run() {
        
            try {
        
                Object o = aClass.newInstance();
                //1.先获取每个方法上的指定注解
                Method[] methods = aClass.getMethods();
                for (Method method : methods) {
        
                    try {
        
                        if (key.equals(aClass.getName() +"."+ method.getName())) {
        
                            method.invoke(o);
                            return;
                        }
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
                }
            } catch (InstantiationException | IllegalAccessException e) {
        
                e.printStackTrace();
            }
    
        }
    
    }

**spring的监听器CustomTimerListener**

package com.timer.spring.listener;
    
    import com.timer.CustomTimerUtils;
    import com.timer.spring.CustomTimer;
    import com.timer.spring.CustomTimerCron;
    import com.timer.spring.SpringTimerRunnable;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationListener;
    import org.springframework.context.event.ContextRefreshedEvent;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    
    //用于spring初始化bean完毕后，进行一些其他前提操作
    @Component
    public class CustomTimerListener implements ApplicationListener<ContextRefreshedEvent> {
        
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
        
            AnnotationConfigServletWebServerApplicationContext annotation = (AnnotationConfigServletWebServerApplicationContext) event.getSource();
            ApplicationContext applicationContext = event.getApplicationContext();
            List<Class> bean = getBean(annotation, CustomTimer.class);
            //处理注解然后添加到定时池中
            structureTimer(bean);
        }
    
        //获取spring里所有被CustomTimer注解的Bean的Class
        public List<Class> getBean(AnnotationConfigServletWebServerApplicationContext annotation,Class cl) {
        
            List<Class> classes=new ArrayList<>();
            String[] beanNamesForAnnotation = annotation.getBeanNamesForAnnotation(cl);
            for (String beanName : beanNamesForAnnotation) {
        
                Class<?> aClass = annotation.getBean(beanName).getClass();
                classes.add(aClass);
            }
            return  classes;
        }
    
        //构建定时器
        public  void   structureTimer(List<Class> classes)  {
        
            try {
        
                for (Class aClass : classes) {
        
                    Object o = aClass.newInstance();
                    //1.先获取每个方法上的指定注解
                    Method[] methods = aClass.getMethods();
                    for (Method method : methods) {
        
                        try {
        
                            CustomTimerCron customTimerCron = method.getAnnotation(CustomTimerCron.class);
                            if (customTimerCron==null) {
        
                                continue;
                            }
                            String key=aClass.getName()+"."+method.getName();
                            String cron = customTimerCron.cron();
                            String startTime = StringUtils.isBlank(customTimerCron.startTime())?null:customTimerCron.startTime();
                            Integer count = customTimerCron.count()==-1?null:customTimerCron.count();
                            CustomTimerUtils.creadTimer(key,new SpringTimerRunnable(aClass,key),startTime,cron,count);
                        } catch (Exception e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            } catch (InstantiationException | IllegalAccessException e) {
        
                e.printStackTrace();
            }
    
        }
    
    }

**测试类**

package com.timer.spring.test;
    
    import com.timer.spring.CustomTimer;
    import com.timer.spring.CustomTimerCron;
    
    @CustomTimer
    public class TestCustomTimer {
        
    
    //    @CustomTimerCron(cron = "0/9 * * * * ?")
    //    public void timer1() {
        
    //        System.out.println("TestCustomTimer-timer1");
    //    }
    //
    //    @CustomTimerCron(startTime ="2022-02-18 16:21:00" ,cron = "0/9 * * * * ?")
    //    public void timer2() {
        
    //        System.out.println("TestCustomTimer-timer2");
    //
    //    }
    
        @CustomTimerCron(startTime ="2022-02-18 16:21:00" ,cron = "0 * * * * ?",count = 5)
        public void timer3() {
        
            System.out.println("TestCustomTimer-timer3");
        }
    }

#### 温馨提示 ####

以上代码部分工具类没有提供,可以自行根据逻辑编写相应的代码来完善

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复如有侵权，请私信联系我感谢,配合,希望我的努力对你有帮助^\_^

![ceaefc422a4745479fc1e8cfd2bdb74e.jpg][]

[ceaefc422a4745479fc1e8cfd2bdb74e.jpg]: https://img-blog.csdnimg.cn/ceaefc422a4745479fc1e8cfd2bdb74e.jpg