Java 定时器的多种实现方式

更新时间：2021年06月07日 08:40:35 作者：卷卷啊

本文介绍了Java中定时器的多种实现方式，有此需求的朋友可以根据实际选择适合自己的方式

一、前言

定时器有三种表现形式：

按固定周期定时执行
延迟一定时间后执行
指定某个时刻执行

JDK 提供了三种常用的定时器实现方式，分别为：

Timer
DelayedQueue 延迟队列
ScheduledThreadPoolExecutor

（1）Timer

发现 eureka 中大量使用了 Timer 定时器：

Timer 属于 JDK 比较早期版本的实现，它可以实现固定周期的任务，以及延迟任务。
Timer 会起动一个异步线程去执行到期的任务，任务可以只被调度执行一次，也可以周期性反复执行多次。

Timer 是如何使用的，示例代码如下：

Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
    @Override
    public void run() {
        // 业务代码
    }
}, 5000, 5000);  // 5s 后调度一个周期为 5s 的定时任务

TimerTask 是实现了 Runnable 接口的抽象类
Timer 负责调度和执行 TimerTask

Timer 的内部构造，如下：

public class Timer {
    // 小根堆，run操作 O(1)、新增 O(logn)、cancel O(logn)
    private final TaskQueue queue = new TaskQueue();
    // 创建另外线程，任务处理，会轮询 queue
    private final TimerThread thread = new TimerThread(queue);
    public Timer(String name) {
        thread.setName(name);
        thread.start();
    }
}

Timer 它是存在不少设计缺陷的，所以并不推荐用户使用：

Timer 是单线程模式，如果某个 TimerTask 执行时间很久，会影响其他任务的调度。
Timer 的任务调度是基于系统绝对时间的，如果系统时间不正确，可能会出现问题。
TimerTask 如果执行出现异常，Timer 并不会捕获，会导致线程终止，其他任务永远不会执行。

（2）DelayedQueue 延迟队列

特征如下：

DelayedQueue 是 JDK 中一种可以延迟获取对象的阻塞队列，其内部是采用优先级队列 PriorityQueue 存储对象
DelayQueue 中的每个对象都必须实现 Delayed 接口，并重写 compareTo 和 getDelay 方法

DelayedQueue 的使用方法如下：

public class DelayQueueTest {
    public static void main(String[] args) throws Exception {
        BlockingQueue<SampleTask> delayQueue = new DelayQueue<>();
        long now = System.currentTimeMillis();
        delayQueue.put(new SampleTask(now + 1000));
        delayQueue.put(new SampleTask(now + 2000));
        delayQueue.put(new SampleTask(now + 3000));
        for (int i = 0; i < 3; i++) {
            System.out.println(new Date(delayQueue.take().getTime()));
        }
    }
    static class SampleTask implements Delayed {
        long time;
        public SampleTask(long time) {
            this.time = time;
        }
        public long getTime() {
            return time;
        }
        @Override
        public int compareTo(Delayed o) {
            return Long.compare(this.getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS));
        }
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(time - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }
    }
}

（3）ScheduledThreadPoolExecutor

JDK 提供了功能更加丰富的 ScheduledThreadPoolExecutor

public class ScheduledExecutorServiceTest {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
        executor.scheduleAtFixedRate(() -> System.out.println("Hello World"), 1000, 2000, TimeUnit.MILLISECONDS); // 1s 延迟后开始执行任务，每 2s 重复执行一次
    }
}

ScheduledThreadPoolExecutor 使用了阻塞队列 DelayedWorkQueue。

（4）ScheduledThreadPoolExecutor

线程应该是最常见的实现方案，创建一个线程执行任务即可，举例几个不同的写法，代码如下

4.1.使用thread + runnable

package com.yezi_tool.demo_basic.test;

import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class ThreadTest {

    private Integer count = 0;

    public ThreadTest() {
        test1();
    }

    public void test1() {
        new Thread(() -> {
            while (count < 10) {
                System.out.println(new Date().toString() + ": " + count);
                count++;
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

4.2.使用线程池 + runnable

package com.yezi_tool.demo_basic.test;

import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Component
public class ThreadTest {

    private static final ExecutorService threadPool = Executors.newFixedThreadPool(5);// 线程池
    private Integer count = 0;

    public ThreadTest() {
        test2();
    }

    public void test2() {
        threadPool.execute(() -> {
            while (count < 10) {
                System.out.println(new Date().toString() + ": " + count);
                count++;
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

以上就是Java 定时器的多种实现方式的详细内容，更多关于Java 定时器的实现的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

详解Java的Exception异常机制
Java的Exception异常机制,为什么会突然聊到异常？其实不是突然,而是我已经准备了很久,但苦于没有好的例子来讲解,从表象到底层实现,今天就带大家详细了解Exception异常,需要的朋友可以参考下
2021-05-05
Java中精确的浮点运算操作示例
这篇文章主要介绍了Java中精确的浮点运算操作方法,结合具体实例形式分析了java浮点数运算的相关函数、使用技巧与注意事项,需要的朋友可以参考下
2017-06-06
spring-boot整合ehcache实现缓存机制的方法
spring-boot是一个快速的集成框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。这篇文章主要介绍了spring-boot整合ehcache实现缓存机制,需要的朋友可以参考下
2018-01-01
Java中static变量作用和用法详解
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问.下面我们来详细了解一下吧
2019-06-06
浅析java 10中的var关键字用法
2018年3月20日，Oracle发布java10。java10为java带来了很多新特性。这篇文章主要介绍了Java 10 var关键字详解和示例教程,需要的朋友可以参考下
2018-10-10
排序算法图解之Java归并排序的实现
归并排序是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。本文主要介绍了归并排序的实现，需要的可以参考一下
2022-11-11
java调用webService接口的代码实现
本文主要介绍了java调用webService接口的代码实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-02-02
Java中SPI机制的实现详解
SPI（Service Provider Interface）,是 JDK 内置的一种服务提供发现机制,可以用来启用框架扩展和替换组件,下面我们就来看看Java中SPI机制的具体实现
2024-01-01
JAVA中数组从小到大排序的2种方法实例
JAVA中在运用数组进行排序功能时一般有多种解决方案,下面这篇文章主要给大家介绍了关于JAVA中数组从小到大排序的2种方法,文中都给出了详细的实例代码,需要的朋友可以参考下
2023-03-03
Java JDK与cglib动态代理有什么区别
这篇文章主要介绍了Java JDK动态代理和cglib动态代理的区别文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习吧
2023-03-03