Java任务定时执行器案例的实现

目录
  • ️前面的话️
  • 1.定时器概述
    • 1.1认识定时器
    • 1.2Timer类的使用
  • 2.定时器的简单实现

️前面的话️

本篇文章将介绍Java多线程案例,定时器,定时器就像闹钟一样,等到了指定的时间,闹钟就会发出响声来提醒您,而定时器会执行指定的任务。

1.定时器概述

1.1认识定时器

java中的定时器,也可以叫做任务定时执行器,顾名思义,就是等到了指定的时间,就去做指定的事情,就像你每周六或周日都要去力扣参加周赛一样。

所以你如果想要使用定时器,你需要交代时间和对应的任务才行,java标准也提供了带有定时器功能的类Timer

1.2Timer类的使用

在java1.8中,Timer给出了四个构造方法,这些构造方法可以去指定线程的名字和是否将定时器内部的线程指定为守护线程。

好了,又出现了一个新概念,这个守护线程是什么鬼?
其实在java中有两种线程,一种是用户线程,另外一种是守护线程。用户线程就是普通的线程,守护线程顾名思义就是守护用户线程的线程,可以说就是用户线程的保姆,守护线程与JVM“共存亡”, 只要存在一个用户线程,程序中所有的守护线程都不会停止工作,直到最后一个用户线程执行完毕,守护线程才会停止工作。守护线程最典型的应用就是 GC (垃圾回收器),它就是一个非常称职的守护者。

构造方法:

序号 构造方法 说明
1 public Timer() 无参数构造方法,默认定时器关联的线程不是守护线程,线程名字也是默认值
2 public Timer(boolean isDaemon) 指定定时器中关联的线程是否为守护线程,如果是,参数为true
3 public Timer(String name) 指定定时器关联线程名称,线程类型默认为非守护线程
4 public Timer(String name, boolean isDaemon) 指定定时器关联线程名和线程类型

Timer类构造时内部也会创建线程,如果不指定,定时器对象内部的线程(为了简化,就称为关联线程吧)的类型是用户线程,而不是守护线程。

核心方法:

序号 方法 说明
1 public void schedule(TimerTask task, long delay) 指定任务,延迟多久执行该任务
2 public void schedule(TimerTask task, Date time) 指定任务,指定任务的执行时间
3 public void schedule(TimerTask task, long delay, long period) 连续执行指定任务,延迟时间,连续执行任务的时间间隔,毫秒为单位
4 public void schedule(TimerTask task, Date firstTime, long period) 连续执行指定任务,第一次任务的执行时间,连续执行任务的时间间隔
5 public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) 与方法4作用相同
6 public void scheduleAtFixedRate(TimerTask task, long delay, long period) 与方法3作用相同
7 public void cancel() 终止定时器所有任务,终止执行的任务不受影响

使用演示:

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.PriorityBlockingQueue;

public class TimeProgram {
    public static void main(String[] args) throws InterruptedException {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行延后2s执行的任务!");
            }
        }, 2000);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行延后5s执行的任务!");
            }
        }, 5000);

        //每秒输出一个mian
        for (int i = 0; i < 5; i++) {
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

运行结果:

TimerTask类就是专门描述定时器任务的一个抽象类,它实现了Runnable接口。

public abstract class TimerTask implements Runnable    //jdk源码

下面我们简单实现一下定时器,我们就不用TimerTask了,我们直接使用Runnable,因为TimerTask实现了Runnable接口,所以后面测试我们自己所写的schedule方法时,也可以传入TimerTask类型的引用,既然是简单地实现,那就不实现连续执行的功能了。

2.定时器的简单实现

首先,我们需要建造一个类,来描述定时器的任务,可以使用Runnable加上一个任务执行的时间戳就可以了。
具体清单:
一个构造方法,用来指定任务和延迟执行时间。
两个获取方法,用来给外部对象获取该对象的任务和执行时间。
实现比较器,用于定时器任务对象的组织,毕竟,每次需要执行时间最早的任务,需要用到基于小根堆实现的优先队列,不,还需要考虑多线程的情况,还是使用优先级阻塞队列吧。

//我的任务
class MyTask implements Comparable<MyTask> {
    //接收具体任务
    private Runnable runnable;
    //执行时的时间戳
    private long time;

    //构造方法
    public MyTask(Runnable runnable, int delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    //执行任务
    public void run() {
        this.runnable.run();
    }
    //获取执行时间
    public long getTime() {
        return this.time;
    }

    //实现comparable接口,方便创建优先级阻塞队列
    @Override
    public int compareTo(MyTask o) {
        return (int) (this.time - o.time);
    }
}

接下来就要实现定时器类了,首先我们需要一个数据结构来组织定时器任务,并且每次都能将时间最早的任务找到并执行,那么这个数据结构非小根堆莫属了,也就是优先级队列,注意对自定义类使用优先级队列时,一定要实现比较器。

    //每次执行任务时,需要优先执行时间在前的任务,即每次执行任务要选择时间戳最小的任务,在多线程情况中优先级阻塞队列是最佳选择
    private static final PriorityBlockingQueue<MyTask> priorityBlockingQueue = new PriorityBlockingQueue<>();

然后,需要一个方法将任务安排在优先级阻塞队列中,最后在构造定时器对象的时候从优先级阻塞队列中取任务并在指定的时间执行。

按照上图的逻辑,我们自己实现的定时器类需要有一个线程专门去执行任务,执行任务过程中可能会遇到执行时间还没有到的情况,那么线程必须得等待,线程等待的方法有两种,一种是wait另一种是sleep,这个案例我们推荐前者,因为sleep方法不能中途唤醒,这个案例是有可能需要中途唤醒的,那就是有新任务插入时,需要重新去优先级阻塞队列拿任务重复上述操作,这个唤醒操作可以使用notify方法实现,所以需要用到wait/notify组合拳,既然需要使用wait/notify那么就得有锁,所以我们可以使用一个专门的锁对象来加锁。

实现代码:

//我的定时类 用来管理任务
class MyTimer {
    //专门对锁对象
    private final Object locker = new Object();
    //每次执行任务时,需要优先执行时间在前的任务,即每次执行任务要选择时间戳最小的任务,在多线程情况中优先级阻塞队列是最佳选择
    private static final PriorityBlockingQueue<MyTask> priorityBlockingQueue = new PriorityBlockingQueue<>();

    //安排任务
    public void schedule(Runnable runnable, int delay) {
        //将任务放入小根堆中
        MyTask task = new MyTask(runnable, delay);
        priorityBlockingQueue.put(task);
        //每次当新任务加载到阻塞队列时,需要中途唤醒线程,因为新进来的任务可能是最早需要执行的
        synchronized (locker) {
            locker.notify();
        }
    }
    public MyTimer() {
        Thread thread = new Thread(() -> {
            while (true) {
                try {
                    //加载任务,确定执行时机
                    MyTask myTask = priorityBlockingQueue.take();
                    long curTime = System.currentTimeMillis();
                    //时间未到,将任务放回
                    if (curTime < myTask.getTime()) {
                        synchronized (locker) {
                            priorityBlockingQueue.put(myTask);
                            //放回任务后,不能立即就再次取该任务加载,需要设置一个再次加载的等待时间,建议使用wait带参数的方法
                            //因为wait方法可以使用notify进行中途唤醒,而sleep不能中途唤醒
                            int delay = (int)(myTask.getTime() - curTime);
                            locker.wait(delay);
                        }
                    } else {
                        System.out.println(Thread.currentThread().getName() + "线程收到任务,正在执行中!");
                        myTask.run();
                        System.out.println(Thread.currentThread().getName() + "线程执行任务完毕,正在等待新任务!");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //不要忘了启动线程
        thread.start();
    }
}

上面是我们实现定时器的代码,我们来测试一下:

import java.util.TimerTask;
import java.util.concurrent.PriorityBlockingQueue;

public class TimeProgram {
    public static void main(String[] args) throws InterruptedException {
        MyTimer timer = new MyTimer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行延后2s执行的任务!");
            }
        }, 2000);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行延后5s执行的任务!");
            }
        }, 5000);

        //每秒输出一个mian
        for (int i = 0; i < 5; i++) {
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

执行结果:

好了,任务定时执行器你学会了吗?

到此这篇关于Java任务定时执行器案例的实现的文章就介绍到这了,更多相关Java任务定时执行器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java当中的定时器的4种使用方式

    对于开发游戏项目的同胞来说,Timer 这个东西肯定不会陌生,今天对以前自己经常使用的定时进行了一番小小的总结!没有写具体实现的原理,只是列举出了其中的四种比较常见的使用方法,相对而言,所以只要按照其所列举的例子仿照即可! import java.util.Calendar; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimeTest { public stati

  • Java实现一个简单的定时器代码解析

    定时的功能我们在手机上见得比较多,比如定时清理垃圾,闹钟,等等.定时功能在java中主要使用的就是Timer对象,他在内部使用的就是多线程的技术. Time类主要负责完成定时计划任务的功能,就是在指定的时间的开始执行某个任务. Timer类的作用是设置计划任务,而封装任务内容的类是TimerTask类.此类是一个抽象类,继承需要实现一个run方法. 利用java制作定时器比较简单,有现成的接口帮助实现.java中制作定时器使用的是Timer和TimerTask,是util包的.java.util

  • java使用TimerTask定时器获取指定网络数据

    复制代码 代码如下: import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.net.URL;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Timer;import java.util.TimerTask; public class GetYinInf

  • Java 定时器(Timer,TimerTask)详解及实例代码

     Java 定时器 在JAVA中实现定时器功能要用的二个类是Timer,TimerTask Timer类是用来执行任务的类,它接受一个TimerTask做参数 Timer有两种执行任务的模式,最常用的是schedule,它可以以两种方式执行任务:1:在某个时间(Data),2:在某个固定的时间之后(int delay).这两种方式都可以指定任务执行的频率,本文有二个例子,一个是简单的一个是用了内部类 1.简单实例 先写一个类 public class TimeTest { public stat

  • Java 定时器(Timer)及线程池里使用定时器实例代码

    java Timer定时器 简单实例代码: public class Test { public static void main(String[] args) { // Timer定时器 Timer mTimer = new Timer(); MyTack myTack = new MyTack(); mTimer.schedule(myTack, 2000, 3000);//第一个参数是需要执行的任务 第二个参数是延迟多少时间最开始执行,第三个参数是执行完后多少时间后进行再次执行是一个周期性

  • JAVA中 Spring定时器的两种实现方式

    目前有两种流行Spring定时器配置:Java的Timer类和OpenSymphony的Quartz. 1.Java Timer定时 首先继承java.util.TimerTask类实现run方法 import java.util.TimerTask; public class EmailReportTask extends TimerTask{ @Override public void run() { ... } } 在Spring定义 ... 配置Spring定时器 <bean id=&quo

  • java实现多线程之定时器任务

    在Java中Timer是java.util包中的一个工具类,提供了定时器的功能.我们可以创建一个Timer对象,然后调用其schedule方法在某个特定的时间去执行一个特定的任务.并且你可以让其以特定频率一直执行某个任务,这个任务是用TimerTask来描述的,我们只需要将要进行的操作写在TimerTask类的run方法中即可.先附上两个小例子一遍让读者了解什么是定时器.接着再分析其中的一些源码实现. 第一个小例子: package com.zkn.newlearn.thread; import

  • java 定时器线程池(ScheduledThreadPoolExecutor)的实现

    前言 定时器线程池提供了定时执行任务的能力,即可以延迟执行,可以周期性执行.但定时器线程池也还是线程池,最底层实现还是ThreadPoolExecutor,可以参考我的另外一篇文章多线程–精通ThreadPoolExecutor. 特点说明 1.构造函数 public ScheduledThreadPoolExecutor(int corePoolSize) { // 对于其他几个参数在ThreadPoolExecutor中都已经详细分析过了,所以这里,将不再展开 // 这里我们可以看到调用基类

  • Java任务定时执行器案例的实现

    目录 ️前面的话️ 1.定时器概述 1.1认识定时器 1.2Timer类的使用 2.定时器的简单实现 ️前面的话️ 本篇文章将介绍Java多线程案例,定时器,定时器就像闹钟一样,等到了指定的时间,闹钟就会发出响声来提醒您,而定时器会执行指定的任务. 1.定时器概述 1.1认识定时器 java中的定时器,也可以叫做任务定时执行器,顾名思义,就是等到了指定的时间,就去做指定的事情,就像你每周六或周日都要去力扣参加周赛一样. 所以你如果想要使用定时器,你需要交代时间和对应的任务才行,java标准也提供

  • Java之SpringBoot定时任务案例讲解

    1. SpringBoot--任务:定时任务 项目开发中经常需要执行一些定时任务,比如需要在每天凌晨的时候, 分析一次前一天的日志信息,Spring为我们提供了异步执行任务调度的方式,提供了 两个接口和两个注解,并且用corn表达式去定时. TaskScheduler //任务调度程序 TaskExecutor //任务执行者 @EnableScheduling //开启定时功能的注解,放在主入口 @Scheduled //什么时候执行 cron表达式 1.1 编写定时任务的方法 我们里面存在一

  • java操作elasticsearch的案例解析

    这篇文章主要介绍了java操作elasticsearch的案例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 到目前为止,我们一直都是使用RESTful风格的 API操作elasticsearch服务,但是通过我们之前的学习知道,elasticsearch提供了很多语言的客户端用于操作elasticsearch服务,例如:java.python..net.JavaScript.PHP等.而我们此次就学习如何使用java语言来操作elasti

  • java Timer 定时每天凌晨1点执行任务

    下面给大家介绍java Timer 定时每天凌晨1点执行任务,具体代码如下所示: import java.util.TimerTask; /** * 执行内容 * @author admin_Hzw * */ public class Task extends TimerTask { public void run() { System.out.println("我有一头小毛驴!"); } } import java.util.Calendar; import java.util.Da

  • Java获取文件ContentType案例

    源码如下: package com.oysept; import java.io.File; import java.io.IOException; import java.net.FileNameMap; import java.net.URLConnection; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import javax.activation.Mimetype

  • Java之网络编程案例讲解

    Java基础之网络编程 基本概念 IP:每个电脑都有一个IP地址,在局域网内IP地址是可变的. 网络通信协议:通信协议是对计算机必须遵守的规则,只有遵守这些规则,计算机之间才能进行通信.这就好比在道路中行驶的汽车一定要遵守交通规则一样,协议中对数据的传输格 式.传输速率.传输步骤等做了统一规定,通信双方必须同时遵守,最终完成数据交换. TCP协议(传输控制协议):是面向连接的传输层协议,应用程序在使用TCP之前,必须先建立TCP连接,在传输数据完毕后,必须释放已经建立的连接(跟打电话是否类似).

  • Java之Jackson使用案例详解

    序列化 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程.在序列化期间,对象将其当前状态写入到临时或持久性存储区.以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象. Json是什么? Jason是 JavaScript Object Notation-  JavaScript对象表示法,是一种轻量级数据交换格式.主要用于数据传输,比如说在后端写了一个Java对象,想在其他地方(前端)使用这个对象,就需要转换为Json这种形式进行传输. 1.

  • Java之类加载机制案例讲解

    1.类加载 <1>.父子类执行的顺序 1.父类的静态变量和静态代码块(书写顺序) 2.子类的静态变量和静态代码块(书写顺序) 3.父类的实例代码块(书写顺序) 4.父类的成员变量和构造方法 5.子类的实例代码块 6.子类的成员变量和构造方法 <2>类加载的时机 如果类没有进行初始化,则需要先进行初始化,虚拟机规范则是严格规定有且只有5种情况必须先对类进行初始化(而加载,验证,准备要在这个之前开始) 1.创建类的实例(new的方式),访问某个类的静态变量,或者对该静态变量赋值,调用类

  • Java操作数据库连接池案例讲解

    数据库连接池 概念:其实就是一个容器(集合),存放数据库连接的容器. 概念:其实就是一个容器(集合),存放数据库连接的容器. 当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象归还给容器. 好处: 节约资源 用户访问高效 实现: 标准接口:DataSource javax.sql包下的 方法: 获取连接:getConnection() 归还连接:Connection.close().如果连接对象Connection是从

  • Java对象创建内存案例解析

    Java对象创建内存图解析 1. 栈 Java栈的区域很小 , 特点是存取的速度特别快,栈存储的特点是, 先进后出,存储速度快的原因: 栈内存, 通过 栈指针'来创建空间与释放空间,指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存.这种方式速度特别快 , 仅次于PC寄存器,但是这种移动的方式, 必须要明确移动的大小与范围 ,明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序的灵活性. 所以我们把更大部分的数据 存储到了堆内存中

随机推荐