定时任务实现方式对比

1. 定时任务实现方式对比

1.1. Timer

• 代码例子以下

public static void main(String[] args) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime localDateTime = LocalDateTime.now();
        String format = localDateTime.format(formatter);
        System.out.println("1:"+format);
        Timer timer = new Timer();
        for (int i = 0; i < 2; i++) {
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread name : "+ Thread.currentThread().getName());
                    LocalDateTime localDateTime = LocalDateTime.now();
                    String format = localDateTime.format(formatter);
                    System.out.println("2:"+format);
                }
            }, 3000);
        }

        localDateTime = LocalDateTime.now();
        format = localDateTime.format(formatter);
        System.out.println("3:"+format);
    }

结果

1:2019-10-14 17:35:13
3:2019-10-14 17:35:13
Thread name : Timer-0
2:2019-10-14 17:35:19
Thread name : Timer-0
2:2019-10-14 17:35:22

• 能够看出同一个Timer的定时任务，后台就一个线程管理任务分配，遇到任务阻塞，可能致使下一个任务延迟
• 且若是任务发生异常，系统就终止了

1.2. ScheduledExecutorService

• 为了解决Timer的问题，ScheduledExecutorService作了改进，采用了线程池的定时任务队列，实际使用的也是最小堆排序
• 代码以下

private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public static void main(String[] args) {
//        timerTest();
        print("1:");
        ScheduledExecutorService service = new ScheduledThreadPoolExecutor(2);
        for (int i = 0; i < 2; i++) {
            service.schedule(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread name : " + Thread.currentThread().getName());
                    print("2:");
                }
            }, 3, TimeUnit.SECONDS);
        }
        print("3:");
        service.shutdown();
    }

    private static void print(String s) {
        LocalDateTime localDateTime = LocalDateTime.now();
        String format = localDateTime.format(formatter);
        System.out.println(s + format);
    }

结果

1:2019-10-15 11:53:54
3:2019-10-15 11:53:54
Thread name : pool-1-thread-1
2:2019-10-15 11:54:00
Thread name : pool-1-thread-2
2:2019-10-15 11:54:00

明白它的延迟原理和Timer同样，能够知道若是我把核心线程数改为1，则效果和Timer相似

• 结果以下，两个任务延迟3秒，前一个任务会致使后一个任务延迟

1:2019-10-15 11:57:40
3:2019-10-15 11:57:40
Thread name : pool-1-thread-1
2:2019-10-15 11:57:46
Thread name : pool-1-thread-1
2:2019-10-15 11:57:49

• 它的优点在于能够多线程执行，必定程度上避免任务间互相影响，同时单个任务异常不影响其它任务

1.3. 时间轮（延迟消息）

• 本质是环形数组，好比上述8个节点的时间轮，每一个节点存听任务队列，好比咱们须要新建5s延迟的任务，就放5的节点，新建10s延迟的任务就放2的节点，设延迟时间为n，则节点位置为n%8，同时需记下轮询圈数n/8
• 优点：当任务数量很是多的时候采用这样环形数组加队列是个效率比较高的选择
• 想要了解更多时间轮实现，能够参考文章下的参考博客

1.4. 分布式定时任务

• github上也有些开源的分布式定时任务的方案，能够直接使用
• 如xxl_job，elastic-job-lite，light-task-scheduler，以哪一个火用哪一个的原则，那仍是xxl_job的星星最多，另外两个已经两年没更新了

参考博客：
延迟消息之时间轮