Java中使用Timer实现定时执行任务

已于 2024-03-14 23:33:47 修改
阅读量472 收藏 2
点赞数 8
文章标签： java 开发语言
于 2024-03-14 23:31:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64200256/article/details/136724791
版权

1.首先我们定义一个抽象接口

 像这样，这个就是我们要使用的定时执行中重要的回调函数方法

interface Callback {
        void Once_per_second();
}

2. 我们在写一个类用于写我们的接口我这边用的是内部类（有较大误差定时函数）

这样就完成我们的回调方法

static class erratic_function {
}

再然后就是重点部分了，也就是我们的Java定时执行方法的核心代码，但是这个方法执行起来会有极大的误差大致有一下几点（这个对于我们日常使用和开发来说并没有用，所以这个直供参考不建议使用）

1.执行时间从当前开始时间不好处理。

2.程序执行的时间无法减去，导致长时间执行会有无限可能得误差。

static class erratic_function {
        /**
         * @param callback 秒钟执行
         */
        void second_TSTSP(Callback callback) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, 1000);

        }
}

这个方法能使用了我们的定时函数方法然后在以回调的方式执行，还有一个对程序执行速度进行计时的

long startTime = System.currentTimeMillis();
//放入需要检测的执行方法或计算

long endTime = System.currentTimeMillis();
long executionTime = endTime - startTime;

System.out.println("方法执行时间：" + executionTime + "毫秒");

3.定时函数pulls版这个版本是我根据定时函数的多调用进行处理了的，一个定时方法有较大的稳定性暂时没发现啥问题。

直接上代码吧，这种处理方法我尝试了一下测试了半个小时没有发现有超过秒级的有达到100毫秒的误差

 static class rule_function {
        /**
         * 自定义执行
         *
         * @param callback 回调函数
         * @param second   执行时长 秒
         */
        void custom_second(Callback callback, int second) {
            Timer timer = new Timer();
            long sum = second * 1000L;
            // 执行某些操作
            TimerTask tasks = new TimerTask() {
                @Override
                public void run() {
                    // 获取当前时间
                    long currentTime = System.currentTimeMillis();//在每次重新执行时需要重新获取当前时间 防止程序执行时间影响整个程序调用时间规则出现异常
                    int sec = second * 1000;//转换为秒级
                    long delay = sec - (currentTime % sec);//进行计算 当前时间还差多少毫秒到某一个整秒
                    System.out.println(delay);
                    TimerTask task = new TimerTask() {
                        @Override
                        public void run() {
                            long startTime = System.currentTimeMillis();
                            callback.Once_per_second();
                            long endTime = System.currentTimeMillis();
                            long executionTime = endTime - startTime;

                            System.out.println("方法执行时间：" + executionTime + "毫秒");
                        }
                    };
                    timer.schedule(task, delay);

                }
            };
            // 计算距离下一分钟整点的时间差
            // 设置定时任务，在距离下一分钟整点时执行MyTask中的run方法
            timer.schedule(tasks, 0, sum);
        }


        void custom_minute(Callback callback, int second) {
            Timer timer = new Timer();
            long sum = second * 60000L;
            // 执行某些操作
            TimerTask tasks = new TimerTask() {
                @Override
                public void run() {
                    // 获取当前时间
                    long currentTime = System.currentTimeMillis();//在每次重新执行时需要重新获取当前时间 防止程序执行时间影响整个程序调用时间规则出现异常
                    int sec = second * 60000;//转换为秒级
                    long delay = sec - (currentTime % sec);//进行计算 当前时间还差多少毫秒到某一个整秒
                    System.out.println(delay);
                    TimerTask task = new TimerTask() {
                        @Override
                        public void run() {

                        }
                    };
                    timer.schedule(task, delay);

                }
            };
            // 计算距离下一分钟整点的时间差
            // 设置定时任务，在距离下一分钟整点时执行MyTask中的run方法
            timer.schedule(tasks, 0, sum);
        }

    }

4.在来一个完整代码吧

package com.mrmt.Time_processing;

import java.text.SimpleDateFormat;
import java.util.*;

public class Time_processing {

    interface Callback {
        void Once_per_second();
    }

    static class rule_function {
        /**
         * 自定义执行
         *
         * @param callback 回调函数
         * @param second   执行时长 秒
         */
        void custom_second(Callback callback, int second) {
            Timer timer = new Timer();
            long sum = second * 1000L;
            // 执行某些操作
            TimerTask tasks = new TimerTask() {
                @Override
                public void run() {
                    // 获取当前时间
                    long currentTime = System.currentTimeMillis();//在每次重新执行时需要重新获取当前时间 防止程序执行时间影响整个程序调用时间规则出现异常
                    int sec = second * 1000;//转换为秒级
                    long delay = sec - (currentTime % sec);//进行计算 当前时间还差多少毫秒到某一个整秒
                    System.out.println(delay);
                    TimerTask task = new TimerTask() {
                        @Override
                        public void run() {
                            long startTime = System.currentTimeMillis();
                            callback.Once_per_second();
                            long endTime = System.currentTimeMillis();
                            long executionTime = endTime - startTime;

                            System.out.println("方法执行时间：" + executionTime + "毫秒");
                        }
                    };
                    timer.schedule(task, delay);

                }
            };
            // 计算距离下一分钟整点的时间差
            // 设置定时任务，在距离下一分钟整点时执行MyTask中的run方法
            timer.schedule(tasks, 0, sum);
        }


        void custom_minute(Callback callback, int second) {
            Timer timer = new Timer();
            long sum = second * 60000L;
            // 执行某些操作
            TimerTask tasks = new TimerTask() {
                @Override
                public void run() {
                    // 获取当前时间
                    long currentTime = System.currentTimeMillis();//在每次重新执行时需要重新获取当前时间 防止程序执行时间影响整个程序调用时间规则出现异常
                    int sec = second * 60000;//转换为秒级
                    long delay = sec - (currentTime % sec);//进行计算 当前时间还差多少毫秒到某一个整秒
                    System.out.println(delay);
                    TimerTask task = new TimerTask() {
                        @Override
                        public void run() {

                        }
                    };
                    timer.schedule(task, delay);

                }
            };
            // 计算距离下一分钟整点的时间差
            // 设置定时任务，在距离下一分钟整点时执行MyTask中的run方法
            timer.schedule(tasks, 0, sum);
        }

    }

    // 包含回调方法的类
    static class erratic_function {
        /**
         * @param callback 秒钟执行
         */
        void second_TSTSP(Callback callback) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, 1000);

        }

        /**
         * @param callback 分钟执行
         */
        void minute_TSTSP(Callback callback) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, 60000);

        }

        /**
         * @param callback 小时
         */
        void hour_TSTSP(Callback callback) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, 3600000);

        }

        /**
         * @param callback 天
         */
        void day_TSTSP(Callback callback) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, 3600000 * 24);
        }

        /**
         * @param callback 回调内容
         * @param minute   回调时长分钟级
         */
        void custom_minute(Callback callback, int minute) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, minute * 60000);
        }

        /**
         * @param callback    回调内容
         * @param millisecond 回调时长 毫秒
         */
        void custom_millisecond(Callback callback, int millisecond) {
            // 执行某些操作
            Timer timer = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    callback.Once_per_second();

                    long endTime = System.currentTimeMillis();
                    long executionTime = endTime - startTime;

                    System.out.println("方法执行时间：" + executionTime + "毫秒");
                }
            };
            timer.schedule(task, 0, millisecond);
        }
    }

    public static void Content_display(Object... T) {
        System.out.println("按照传入顺序打印");
        for (Object o : T) {
            int lastIndex = o.getClass().getName().lastIndexOf(".");
            String result = o.getClass().getName().substring(lastIndex + 1);
            System.out.println(" 类型 : " + result + " 内容 : " + o);
        }
    }

    public static void main(String[] args) {
        erratic_function example = new erratic_function();
        rule_function rule_function = new rule_function();


        rule_function.custom_second(new Callback() {
            @Override
            public void Once_per_second() {
                Date currentTime = new Date();
                // 定义时间格式
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
                // 格式化时间并打印
                String formattedTime = sdf.format(currentTime);
                System.out.println("十秒: " + formattedTime);
                System.out.println("启动");
            }
        }, 10);


        rule_function.custom_minute(new Callback() {
            @Override
            public void Once_per_second() {
                Date currentTime = new Date();
                // 定义时间格式
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
                // 格式化时间并打印
                String formattedTime = sdf.format(currentTime);
                System.out.println("一分: " + formattedTime);
                System.out.println("启动");
            }
        }, 1);


    }
}

下面这个是我写的一个打印方法还没完善好希望有想法的铁汁评论一下说一下咋改比较合适

package com.mrmt.Time_processing;

public class Main {
    public static void main(String[] args) {
        gets("1", 2, "3");
    }

    public static void gets(String name, int age, String type) {
        Content_display(name, age, type);
    }

    public static void Content_display(Object... T) {
        System.out.println("按照传入顺序打印");
        for (Object o : T) {
            int lastIndex = o.getClass().getName().lastIndexOf(".");
            String result = o.getClass().getName().substring(lastIndex + 1);
            System.out.println(" 类型 : " + result + " 内容 : " + o);
        }
    }


}

吃亏了的程序猿
关注
java timer定时执行一次_Java Timer（定时调用、实现固定时间执行）
weixin_35867979的博客
02-13 803
而定义TimerThread部分的是：看到这里知道了，Timer内部包装了一个线程，用来做独立于外部线程的调度，而TimerThread是一个default类型的，默认情况下是引用不到的，是被Timer自己所使用的。接下来看下有那些属性除了上面提到的thread，还有一个很重要的属性是：private TaskQueue queue = new TaskQueue();看名字就知道是一个队列，队列...
timerTask实现每天定时一段时间内执行定时任务
12-11
timerTask实现每天定时一段时间内执行定时任务，这个是自己写的代码，有些和我的项目有关，可以删掉，但是其主要的都在里面，我写了注释。
java timer类的功能,Java：利用java Timer类实现定时执行任务的功能
weixin_30753697的博客
03-13 148
一、概述在java中实现定时执行任务的功能，主要用到两个类，Timer和TimerTask类。其中Timer是用来在一个后台线程按指定的计划来执行指定的任务。TimerTask一个抽象类，它的子类代表一个可以被Timer计划的任务，具体要执行的代码写在TimerTask需要被实现的run方法中。二、先看一个最简单的例子我们通过代码来说明importjava.text.SimpleDateForma...
java的Timer，定时执行某个任务
kouriba
06-14 108
写了一个Timer的工具类，比较通用，用于定时执行某个任务，时间可以自定义配置 package com.shutao.test.schedule; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.Timer; import java.util...
Timer定时任务
lzy_clement的专栏
12-01 96
利用Timer类创建出一个对象,其中有schedule()方法制定任务要执行的时间间隔,精确时间等. (delay:程序开启后多长时间运行任务60*1000=1分钟  period:任务执行的间隔时间)   schedule方法里有一个Task任务,所执行的方法均在一个类中,此类必须继承TimerTask类...
Java定时任务：利用java Timer类实现定时执行任务的功能
09-01
【Java定时任务：利用java Timer类实现定时执行任务的功能】 在Java编程中，有时我们需要在特定的时间点或者按照预设的间隔执行某些任务，这就需要用到定时任务。Java提供了`java.util.Timer`类来帮助我们实现这个...
java Timer 定时每天凌晨1点执行任务
08-25
在本篇文章中，我们将学习如何使用Java Timer来实现每天凌晨1点执行任务的功能。 首先，让我们了解一下 Timer类的基本概念。Timer类是一个抽象类，它提供了一个方法来安排执行任务的时间。我们可以使用Timer类来...
Java循环调用多个timer实现定时任务
08-18
Java 中实现定时任务有多种方法，其中一种常用的方法是使用 Timer 和 TimerTask 实现循环调用多个 Timer 实现定时任务。在 Java 中，Timer 是一个用于在特定时间执行任务的工具，而 TimerTask 则是 Timer 的一个任务...
java定时任务Timer和TimerTask使用详解
08-31
如果你希望在特定的时间点执行任务，可以使用 `java.util.Calendar` 类设置时间，然后将 `Calendar` 对象转换为 `Date`，传递给 `schedule` 方法： ```java Calendar calendar = Calendar.getInstance(); ...
JAVA使用Timer实现定时任务
通过这个简单的示例，我们可以了解到如何在Java中使用`Timer`和`TimerTask`来创建定时任务。然而，需要注意的是，`Timer`类并不是线程安全的，如果多个任务需要并发调度，可能需要考虑使用其他如`...
java定时任务每天执行TimerTask 使用方法
06-04
在 TimerManager 这个类里面，大家一定要注意 时间点的问题。如果你设定在凌晨2点执行任务。但你是在2点以后 发布的程序或是重启过服务，那这样的情况下，任务会立即执行，而不是等到第二天的凌晨2点执行。为了，避免这种情况 发生，只能判断一下，如果发布或重启服务的时间晚于定时执行任务的时间，就在此基础上加一天。
java Timer（定时调用、实现固定时间执行）测试
hl_java的专栏
01-11 2317
java Timer（定时调用、实现固定时间执行）测试 测试1，当任务执行时间小于重复执行的间隔时间 代码： public class TimerTest2 { public static void main(String[] args) throws InterruptedException { Timer timer = new Timer();
java Timer ,TimerTask执行定时任务
henryzhang2009的专栏
01-19 604
public class TimerTaskTest extends java.util.TimerTask {  @Override  public void run() {   // TODO Auto-generated method stub   System.out.println("task start-------");   //以下是需要执行的任务........   
java 中 Timer 定时执行任务
hunan_36的专栏
12-21 925
 今天做的项目中用到了定时器，就翻了一回JAVA API。1 【功能】延迟定时也就是说执行一个任务，在规定时间后，再做另外一个任务（比如 娱乐游戏-斗地主中，限制玩家打牌思考的时间）完成该功能： a、定义一个 Timer 类  ---一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。 b、定义一个TimerTask类，该类继承Runnable接口，由
Timer实现定时任务
海未眠的博客
12-06 273
web.xml配置Listener： <listener> <listener-class>com.prison.controller.TimerManager</listener-class> </listener> 任务类，继承TimerTask类: package com.prison.util; import ja...
Java Timer定时执行任务
最新发布
红旗_1949的博客
08-01 173
【代码】Java Timer定时执行任务。
Timer执行过程
jiangbinbin的博客
06-28 485
Timer 定时器执行过程：Timer TimerTask TimerQueueTimer是一个单线程 + 最小堆 + 不断轮询 Timer time=newTimer();n  调用构造方法创建timer类public Timer(){this("Timer-"+ serialNumber());}private final static AtomicIntegernextSerialNumbe...
用Timer实现定时运行
我的技术笔记
05-26 1635
定时运行这个问题其实老早就接触到了，不过在上次的程序中似乎没有很好的解决这个问题，并且没有深入下去。这次再次碰到同样的问题，在查找了网上的资料以后，对这一问题有了比较深的理解。在程序中实现定时运行的思路：由timer控件实现两个timer控件，其中timer1负责每一分钟检查一次系统时间和设定时间的差值，如果两者相差5分钟，则继续检查，直到当相差时间小于5分钟，触发timer2，timer2的定时
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吃亏了的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值