前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >传统线程技术中的定时器技术

传统线程技术中的定时器技术

作者头像
技术从心
发布2019-08-06 17:03:07
5800
发布2019-08-06 17:03:07
举报
文章被收录于专栏:技术从心

传统线程技术中有个定时器,定时器的类是 Timer,我们使用定时器的目的就是给它安排任务,让它在指定的时间完成任务。所以先来看一下 Timer 类中的方法(主要看常用的 TimerTask() 方法):

返回值

方法名

方法描述

void

schedule(TimerTasktask,longdelay)

安排在指定延迟后执行指定的任务。

void

schedule(TimerTasktask,longdelay,longperiod)

安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

void

schedule(TimerTasktask,Datetime)

安排在指定的时间执行指定的任务

void

schedule(TimerTasktask,DatefirstTime,longperiod)

安排指定的任务在指定的时间开始进行重复的固定延迟执行。

前面两个是在指定延迟后执行或者重复执行,后面两个是在指定时间执行或者重复执行。我们以前两个为例来研究一下定时器的使用。先写一个简单的使用定时器的 demo,然后慢慢引申。

代码语言:javascript
复制
public class TraditionalTimer {

    public static void main(String[] args) {
        //简单定时器的demo
        new Timer().schedule(new TimerTask() {          
            @Override
            public void run() {
                //实际中会扔一个对象进来,我们就可以在这里操作这个对象的所有方法了
                System.out.println("--boom--");//爆炸
            }
        }, 2000,3000); 

        //打印秒钟,一秒输出一次,用来方便观察的
        while(true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}

我们用匿名内部类来定义了一个 TimerTask 对象,需要重写 run() 方法,然后运行这个程序,可以看出来第一次2秒钟后打印 “--boom--,后面每隔3秒打印一次。 我们也可以自己来实现上面这个重复执行,我们用定时器的 “连环套”!也就是定时器中再套定时器,一个定时器任务执行完了,在任务的最后再装一个定时器。那么我们需要先定义一个自己的定时器任务,在自己的定时器任务中再装一个定时器,把自定义的定时器任务扔进去。然后我们开启定时器的时候把自己定义的定时器任务扔进去即可。如下:

代码语言:javascript
复制
public class TraditionalTimer {
    public static void main(String[] args) {

        //自定义一个定时器任务
        class MyTimerTask extends TimerTask {           
            @Override
            public void run() {
                System.out.println("--boom--");
                //任务执行完再装一个定时器,扔进自定义的定时器任务
                new Timer().schedule(new MyTimerTask(), 3000);
            }
        }
        new Timer().schedule(new MyTimerTask(), 2000);//外面开启定时器

        while(true) {//打印秒钟,一秒输出一次
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}

这样的话,我们通过定时器的 “连环套” 很轻松的实现了连环爆炸。但是现在问题来了,上面提供的方法中重复执行都是每隔固定的时间,如果我想要隔2秒执行一次,再隔4秒执行一次,再隔2秒执行一次,再隔4秒执行一次……这该如何实现呢? 可以这样,我们定义一个全局的私有成员变量来记录爆炸次数,奇数的时候隔2秒炸,偶数的次数的话隔4秒炸,或者反过来也行,修改如下:

代码语言:javascript
复制
public class TraditionalTimer {

    private static int count = 0; //记录爆炸的次数
    public static void main(String[] args) {    

        class MyTimerTask extends TimerTask {           
            @Override
            public void run() {
                count = (count + 1) % 2; //结果只有0和1
                System.out.println("--boom--");
                                //根据count结果设定新的定时时间
                new Timer().schedule(new MyTimerTask(), 2000+2000*count);
            }
        }
        new Timer().schedule(new MyTimerTask(), 2000);

        while(true) {//打印秒钟,一秒输出一次
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}

这样的话,我们就实现了自定义爆炸间隔了。上面这个是通过定义一个全局私有变量来实现,其实我们也可以这么干:不是要实现两个不同时间间隔的连环炸么?我可以定义两个定时器任务A和B,在A执行完开启定时器,把B任务装进去,B执行完开启定时器把A装进去,这样也可以。如下:

代码语言:javascript
复制
public class TraditionalTimer {

    public static void main(String[] args) {

        new Timer().schedule(new MyTimerTaskA(), 2000);//A和B随便开一个

        while(true) {//打印秒钟,一秒输出一次
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }

}
//自定义两个定时器任务类,继承TimerTask即可
class MyTimerTaskA extends TimerTask {

    @Override
    public void run() {
        System.out.println("--boomA--");
        new Timer().schedule(new MyTimerTaskB(), 4000);
    }           
}
class MyTimerTaskB extends TimerTask {

    @Override
    public void run() {
        System.out.println("--boomB--");
        new Timer().schedule(new MyTimerTaskA(), 2000);
    }   
}

这样就可以实现自定义时间间隔的连环炸了。传统的定时器技术就总结这么多吧。

在看、转发和辣条会提升颜值哦~

关注我

每天进步一点点

万水千山总是情,点个 “在看” 行不行

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2019-04-18,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 技术从心 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档