Java多线程编程核心技术第五章笔记：定时器Timer

最新推荐文章于 2021-03-21 21:42:05 发布
最新推荐文章于 2021-03-21 21:42:05 发布
阅读量198 收藏
点赞数
分类专栏： Java多线程编程核心技术 文章标签： Java多线程编程核心技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_39334407/article/details/93380002
版权
1、JDK库中Timer主要负责计划任务的功能，也就是说在指定的时间开始执行某一个任务；

定时器五大方法的练习：

1、schedule(TimeTask task,Date time)：在指定的日期执行一次某一任务；
  1. 在未来执行的效果：如果不将Timer改成守护线程，那么每创建一个就是启动了一个新的线程这个新启动的线程并不是守护线程，它一直会处于运行状态，如果将新创建的Timer改成守护线程，程序运行后迅速结束当前的进程，并且TimeerTask中的任务不再被运行，因为进程已经结束了；
  2. 提前当前时间执行任务的效果：立即执行task任务；
    当没有设置为守护线程而在未来执行任务时：
    在这里插入图片描述
    设置为守护线程后：在未来执行：程序运行后迅速结束当前的进程，并且TimeerTask中的任务不再被运行，因为进程已经结束了；
    在这里插入图片描述
代码：
package Day30.Test;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;


/**
 1. 定时器Timer的使用
 2. schedule(TimeTask task,Date time)：
 3. 在指定的日期执行一次某一任务；
*/
public class Test1 {
    private static Timer timer = new Timer(true);
    static public class MyTask extends TimerTask{
        @Override
        public void run() {
            System.out.println("运行了！时间为："+new Date());
        }
    }
    public static void main(String[] args) {


        try {
            MyTask task = new MyTask();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dataString = "2019-06-03 22:00:00";
            Date dateRef = sdf.parse(dataString);
            System.out.println("字符串时间："+ dateRef.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            timer.schedule(task,dateRef);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
  1. 多个TimerTask任务及延时时，TimerTask是以队列的方式一个一个被顺序执行的，所以执行的时间有可能和预期的时间不一致，因为前面的任务有可能消耗的时间较长，那么后面的任务运行的时间也会被延迟；
    实例：结果,注意时间;运行结果：可以看出task1执行任务是立即执行，因为它是早于当前时间执行task2就是晚于当前时间执行，按时执行；
    在这里插入图片描述
例子代码：
package Day30.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
 1. @author Dangxuchao
 2. @Title: Test2
 3. @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
 4. @Description: TODO
 5. @date 2019/6/3 23:14
*/
public class Test2 {
    private static Timer timer = new Timer();
    static public class MyTask1 extends TimerTask{
        @Override
        public void run() {
            System.out.println("Task1运行了！时间为:"+new Date());
        }
    }
    static public class MyTask2 extends TimerTask{
        @Override
        public void run() {
            System.out.println("Task2运行了！时间为："+new Date());
        }
    }
    public static void main(String[] args) {
        try {
            MyTask1 myTask1 = new MyTask1();
            MyTask2 myTask2 = new MyTask2();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString1 = "2019-6-3 23:22:50";
            String dateString2 = "2019-6-3 23:23:20";
            Date dateRef1 = sdf1.parse(dateString1);
            Date dateRef2 = sdf2.parse(dateString2);
            System.out.println("字符串时间："+ dateRef1.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            System.out.println("字符串时间："+ dateRef2.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            timer.schedule(myTask1,dateRef1);
            timer.schedule(myTask2,dateRef2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
/*
运行结果：可以看出task1执行任务是立即执行，因为它是早于当前时间执行
task2就是晚于当前时间执行，按时执行；
    字符串时间：2019-6-3 23:22:50当前时间：2019-6-3 23:23:01
    字符串时间：2019-6-3 23:23:20当前时间：2019-6-3 23:23:01
    Task1运行了！时间为:Mon Jun 03 23:23:01 CST 2019
    Task2运行了！时间为：Mon Jun 03 23:23:20 CST 2019
*/
  1. 当前行的任务Thread()几秒的话，后面的任务也会被顺序延迟：如图，task本来在32秒的时候执行，可是却在34秒才被执行；
    在这里插入图片描述
2、public void schedule(TimerTask task, Date firstTime, long period) ：

作用：在指定的日期之后，按指定的间隔周期性的无限循环地执行某一任务；
7. 在未来执行的效果：从运行结果来看，每隔几秒执行一次TimerTask任务，并且是无限期地重复执行；
8. 在过去的时间点执行的话就是立即打印，并且重复执行；
在这里插入图片描述
9. 任务执行被延时的时候：如果重复执行的时间间隔是4秒，而执行一次任务所花的时间是5秒的花，每间隔5秒才开始下一次执行；
在这里插入图片描述

package Day30.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;


/**
* @author Dangxuchao
* @Title: Test3
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description: schedule(TimerTask task, Date firstTime, long period) ：
* 作用：在指定的日期之后，按指定的间隔周期性的无限循环地执行某一任务；
* 1、
* 在未来执行的效果：从运行结果来看，
* 每隔几秒执行一次TimerTask任务，并且是无限期地重复执行；
* @date 2019/6/3 23:42
*/
public class Test3 {
    private static Timer timer = new Timer();
    static public class MyTask3 extends TimerTask{
        @Override
        public void run() {
            System.out.println("运行了，时间为："+new Date());
        }
    }
    public static void main(String[] args) {
        try{
            MyTask3 myTask3 = new MyTask3();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-6-3 23:51:00";
            Date dateRef3 = sdf.parse(dateString);
            System.out.println("字符串时间："+ dateRef3.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            timer.schedule(myTask3,dateRef3,2000);
        }catch (ParseException e){
            e.printStackTrace();
        }
    }
}
/*
运行时间：


    字符串时间：2019-6-3 23:51:00当前时间：2019-6-3 23:50:27
    运行了，时间为：Mon Jun 03 23:51:00 CST 2019
    运行了，时间为：Mon Jun 03 23:51:02 CST 2019
    运行了，时间为：Mon Jun 03 23:51:04 CST 2019
    运行了，时间为：Mon Jun 03 23:51:06 CST 2019
    运行了，时间为：Mon Jun 03 23:51:08 CST 2019
    运行了，时间为：Mon Jun 03 23:51:10 CST 2019
    运行了，时间为：Mon Jun 03 23:51:12 CST 2019
    运行了，时间为：Mon Jun 03 23:51:14 CST 2019
    运行了，时间为：Mon Jun 03 23:51:16 CST 2019
    运行了，时间为：Mon Jun 03 23:51:18 CST 2019
    运行了，时间为：Mon Jun 03 23:51:20 CST 2019
*/
3、TimerTask类的cancel()方法：将自身从任务队列中清除

在这里插入图片描述

代码：
package Day30.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
* @author Dangxuchao
* @Title: Test4
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description: TimerTask类的cancel()方法：将自身从任务队列中清除
* @date 2019/6/4 0:26
*/
public class Test4 {
    private static Timer timer4 = new Timer();
    static public class MyTask4A extends TimerTask{
        @Override
        public void run() {
            System.out.println("A运行了！时间为："+new Date());
            this.cancel();
            //timer4.cancel();
        }
    }
    static public class MyTask4B extends TimerTask{
        @Override
        public void run() {
            System.out.println("B运行了！时间为："+new Date());
        }
    }
    public static void main(String[] args) {
        try{
            MyTask4A task4A = new MyTask4A();
            MyTask4B task4B = new MyTask4B();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString4 = "2019-6-4 00:39:50";

            Date dateRef4 = sdf.parse(dateString4);
            System.out.println("字符串时间："+ dateRef4.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            timer4.schedule(task4A,dateRef4,2000);
            timer4.schedule(task4B,dateRef4,2000);
        }catch (ParseException e){
            e.printStackTrace();
        }
    }
}
/*
运行结果：

    字符串时间：2019-6-4 0:39:50当前时间：2019-6-4 0:39:54
    A运行了！时间为：Tue Jun 04 00:39:54 CST 2019
    B运行了！时间为：Tue Jun 04 00:39:54 CST 2019
    B运行了！时间为：Tue Jun 04 00:39:56 CST 2019
    B运行了！时间为：Tue Jun 04 00:39:58 CST 2019
    B运行了！时间为：Tue Jun 04 00:40:00 CST 2019
    B运行了！时间为：Tue Jun 04 00:40:02 CST 2019
    B运行了！时间为：Tue Jun 04 00:40:04 CST 2019
    B运行了！时间为：Tue Jun 04 00:40:06 CST 2019
    B运行了！时间为：Tue Jun 04 00:40:08 CST 2019
*/
4、Timer类的cancel()方法：将任务队列中的全部任务清空：

这里注意一下，有时候Timer的cancel()方法有时候并不能停止执行计划任务，而是正常执行这是因为此方法又是并没有争抢到queue锁，所以TimerTask类中的任务继续正常执行

在这里插入图片描述

5、schedule(TimerTask task,long delay)：以当前的时间作为参考时间，在此时间基础上延迟指定delay毫秒后执行一次TimerTask任务；

如图，延迟两秒后：
在这里插入图片描述

package Day30.Test;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
* @author Dangxuchao
* @Title: Test5
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description: 方法schedule(TimerTask task,long delay)：
* 以当前的时间作为参考时间，在此时间基础上延迟指定delay毫秒后执行一次TimerTask任务；
* @date 2019/6/4 7:55
*/

public class Test5 {
    static public class MyTask5 extends TimerTask{
        @Override
        public void run() {
            System.out.println("运行，运行时间为："+new Date());
        }
    }
    public static void main(String[] args) {
        MyTask5 task5 = new MyTask5();
        Timer tiemr = new Timer();
        System.out.println("当前时间为："+new Date().toLocaleString());
        tiemr.schedule(task5,2000);
    }
}
/*
运行结果：

    当前时间为：2019-6-4 8:02:33
    运行，运行时间为：Tue Jun 04 08:02:35 CST 2019

*/
6、public void schedule(TimerTask task, long delay, long period)：延迟执行的条件下加了个周期循环执行；

在这里插入图片描述

scheduleAtFixedRate(TimerTask task, Date firstTime, long period)与public void schedule(TimerTask task, Date firstTime, long period)之间区别：

1、首先来看第一个schedule：
  1. 测试schedule方法任务不延时的情况：周期时间以给定的period为准，任务执行开始时间到下一次任务开始的时间间隔就是周期时间；

在这里插入图片描述

  1. 延时的情况：周期间隔以任务执行时间为准，任务执行延时超出period，以任务执行时间为准；
    在这里插入图片描述
代码：
package Day30.Test;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
* @author Dangxuchao
* @Title: Test6
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description:
* 测试schedule方法不延时的情况
* 还有跟延时时的情况
* @date 2019/6/4 8:09
*/

public class Test6 {
    private static Timer timer = new Timer();
    private static int runCount = 0;

    static public class MyTask6 extends TimerTask{
        @Override
        public void run() {
            try {
                System.out.println("Task开始执行："+new Date());
                Thread.sleep(1000);
                System.out.println("Task结束执行："+new Date());
                runCount++;
                if (runCount == 5){
                    timer.cancel();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {


        try {
            MyTask6 task6 = new MyTask6();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-6-4 8:24:00";
            Date dateRef6 = sdf.parse(dateString);
            System.out.println("字符串时间："+ dateRef6.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            timer.schedule(task6,dateRef6,2000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
/*
运行结果：测试schedule方法不延时的情况，可以看出schedule方法不延时重复执行，
是任务执行时间加上间隔时间才是delay循环周期；

    字符串时间：2019-6-4 8:24:00当前时间：2019-6-4 8:23:30
    Task开始执行：Tue Jun 04 08:24:00 CST 2019
    Task结束执行：Tue Jun 04 08:24:01 CST 2019
    Task开始执行：Tue Jun 04 08:24:02 CST 2019
    Task结束执行：Tue Jun 04 08:24:03 CST 2019
    Task开始执行：Tue Jun 04 08:24:04 CST 2019
    Task结束执行：Tue Jun 04 08:24:05 CST 2019
    Task开始执行：Tue Jun 04 08:24:06 CST 2019
    Task结束执行：Tue Jun 04 08:24:07 CST 2019
    Task开始执行：Tue Jun 04 08:24:08 CST 2019
    Task结束执行：Tue Jun 04 08:24:09 CST 2019
*/
下面来看第二个

scheduleAtFixedRate(TimerTask task, Date firstTime,long period)延时与不延时的区别：

  1. 不延时的情况：就是说不在乎你当下的周期时间，这次任务执行完了之后就接着执行下次任务；

在这里插入图片描述

  1. 延时的结果：跟schedule的结果一样：
    在这里插入图片描述
代码：
package Day30.Test;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;


/**
* @author Dangxuchao
* @Title: Test7
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description: scheduleAtFixedRate(TimerTask task, Date firstTime,long period)
* 延时与不延时的区别：
* @date 2019/6/4 8:52
*/
public class Test7 {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask7 extends TimerTask{
        @Override
        public void run() {

            try {
                System.out.println("开始运行了："+new Date());
                Thread.sleep(3000);
                System.out.println("结束运行了："+new Date());
                runCount++;
                if (runCount == 4){
                    timer.cancel();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) {

        try {
            MyTask7 myTask7 = new MyTask7();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-6-4 8:58:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串时间："+dateRef.toLocaleString()
                    +"当前时间："+new Date());
            timer.scheduleAtFixedRate(myTask7,dateRef,1000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

/*
    延时后的运行结果：，跟schedule的结果一样：

    字符串时间：2019-6-4 8:58:00当前时间：Tue Jun 04 09:01:26 CST 2019
    开始运行了：Tue Jun 04 09:01:26 CST 2019
    结束运行了：Tue Jun 04 09:01:29 CST 2019
    开始运行了：Tue Jun 04 09:01:29 CST 2019
    结束运行了：Tue Jun 04 09:01:32 CST 2019
    开始运行了：Tue Jun 04 09:01:32 CST 2019
    结束运行了：Tue Jun 04 09:01:35 CST 2019
    开始运行了：Tue Jun 04 09:01:35 CST 2019
    结束运行了：Tue Jun 04 09:01:38 CST 2019
*/
/*
不延时的结果：不会被参数中的周期时间period而限制，
本次任务执行完就接着下次的任务执行；
    字符串时间：2019-6-4 8:58:00当前时间：Tue Jun 04 09:02:57 CST 2019
    开始运行了：Tue Jun 04 09:02:57 CST 2019
    结束运行了：Tue Jun 04 09:02:58 CST 2019
    开始运行了：Tue Jun 04 09:02:58 CST 2019
    结束运行了：Tue Jun 04 09:02:59 CST 2019
    开始运行了：Tue Jun 04 09:02:59 CST 2019
    结束运行了：Tue Jun 04 09:03:00 CST 2019
    开始运行了：Tue Jun 04 09:03:00 CST 2019
    结束运行了：Tue Jun 04 09:03:01 CST 2019

*/
8、最后两个测试：
1、验证schedule方法不具有追赶执行性：可以看出9：11：43之前的任务被取消了，不执行了，这就是Task任务不追赶的情况；

在这里插入图片描述

package Day30.Test;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;


/**
* @author Dangxuchao
* @Title: Test8
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description: 验证schedule方法不具有追赶执行性：
* @date 2019/6/4 9:06
*/
public class Test8 {
    private static Timer timer8 = new Timer();
    static public class MyTask8 extends TimerTask{
        @Override
        public void run() {
            System.out.println("开始运行了："+new Date());
            System.out.println("结束运行了："+new Date());
        }
    }
    public static void main(String[] args) {

        try {
            MyTask8 task8 = new MyTask8();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-6-4 9:10:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串时间："+dateRef.toLocaleString()
                    +"当前时间："+new Date());
            timer8.schedule(task8,dateRef,5000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
/*
运行结果：schedule无追赶执行性

    字符串时间：2019-6-4 9:10:00当前时间：Tue Jun 04 09:11:43 CST 2019
    开始运行了：Tue Jun 04 09:11:43 CST 2019
    结束运行了：Tue Jun 04 09:11:43 CST 2019
    开始运行了：Tue Jun 04 09:11:48 CST 2019
    结束运行了：Tue Jun 04 09:11:48 CST 2019
    开始运行了：Tue Jun 04 09:11:53 CST 2019
    结束运行了：Tue Jun 04 09:11:53 CST 2019
    开始运行了：Tue Jun 04 09:11:58 CST 2019
    结束运行了：Tue Jun 04 09:11:58 CST 2019
*/
2、验证scheduleAtFixedRate方法具有追赶性：运行结果：前面时间所对应的任务被补齐了，这就是Task任务追赶执行的特性；

在这里插入图片描述
代码：

package Day30.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
* @author Dangxuchao
* @Title: Test9
* @ProjectName 5.30 Java多线程编程核心技术第五章：定时器Timer
* @Description: 验证scheduleAtFixedRate方法具有追赶性：
* @date 2019/6/4 9:15
*/
public class Test9 {
    private static Timer timer = new Timer();
    public static class MyTask9 extends TimerTask{
        @Override
        public void run() {
            System.out.println("开始执行了："+ new Date());
            System.out.println("结束执行："+ new Date());
        }
    }
    public static void main(String[] args) {

        try {
            MyTask9 task9 = new MyTask9();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-6-4 9:20:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串时间："+ dateRef.toLocaleString()
                    +"当前时间："+ new Date().toLocaleString());
            timer.scheduleAtFixedRate(task9,dateRef,2000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
/*
运行结果：前面时间所对应的任务被补齐了，这就是Task任务追赶执行的特性；
    开始执行了：Tue Jun 04 09:22:29 CST 2019
    结束执行：Tue Jun 04 09:22:29 CST 2019
    开始执行了：Tue Jun 04 09:22:29 CST 2019
    结束执行：Tue Jun 04 09:22:29 CST 2019
    开始执行了：Tue Jun 04 09:22:29 CST 2019
    结束执行：Tue Jun 04 09:22:29 CST 2019
    开始执行了：Tue Jun 04 09:22:29 CST 2019
    结束执行：Tue Jun 04 09:22:29 CST 2019
    开始执行了：Tue Jun 04 09:22:30 CST 2019
    结束执行：Tue Jun 04 09:22:30 CST 2019
    开始执行了：Tue Jun 04 09:22:32 CST 2019
    结束执行：Tue Jun 04 09:22:32 CST 2019
    开始执行了：Tue Jun 04 09:22:34 CST 2019
    结束执行：Tue Jun 04 09:22:34 CST 2019
    开始执行了：Tue Jun 04 09:22:36 CST 2019
    结束执行：Tue Jun 04 09:22:36 CST 2019
    开始执行了：Tue Jun 04 09:22:38 CST 2019
    结束执行：Tue Jun 04 09:22:38 CST 2019
*/
baidu_974079012
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 100个定时任务_java定时任务-java TimeTask-java timer-嗨客网
weixin_35769289的博客
02-16 237
Java定时调度教程在生产的编程场景中，我们需要定期的执行一个方法。我们可以人为的触发这个方法，也可以用定时调度器，定期的调用这个方法。Timer 类就是一种线程设施，可以在一个时间或者某一时间段执行一次或者重复执行该方法。该功能需要与 TimerTask 配合使用。Java TimeTask类TimeTask 是一个抽象类，它会结合定时调度类，如果想要用该类，就需要定义一个子类来实现里面的抽象方...
GD32学习笔记第三章：PWM控制LED
04-17
在本GD32学习笔记第三章中，我们将深入探讨如何使用PWM（脉宽调制）技术来控制LED的亮度。PWM是一种广泛应用于嵌入式系统中的数字模拟转换方法，通过改变脉冲宽度来调节输出信号的平均功率，进而实现对LED亮度的控制...
守护线程与非守护线程，也可以实现定时执行任务
qq_41767337的博客
06-20 359
守护线程： jvm是一个进程，进程的退出前提是保证程序中没有非守护线程的存在，执行完毕就直接退出； main方法就是一个非守护进程 例： public class ThreadTest{ public static class MyThread extends Thread{ @Override public void run(){ while (true){ ...
线程类Thread详解和线程的几种状态，守护线程
请叫我王老魔
03-08 1871
Thread类也是实现了Runnable接口的，它的run方法就是因此而来的class Thread implements Runnable {}Thread几个比较重要的构造方法： Thread() //创建一个线程 Thread(Runnable target) //将一个实现了Runnable接口的类的对象传进来 Thread(String name) // 为线程传进名字为什么必须要通
线程中断的3+2(自定义执行状态和处理不可中断的阻塞)种方式、setDaemon(守护线程)、Future的方法
进化的深山猿
01-23 824
Java分为两种线程：用户线程和守护线程 守护线程是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。 守护线程和用户线程的没啥本质的区别：唯一的不同之处就在于虚拟机的离开：如果用户线...
Java 中的定时器类Timer详解
swadian2008的博客
08-31 1876
Timer是Java中的一个定时器类，用于在指定时间之后执行某些任务，也可以在指定时间间隔内周期性地执行某些任务。它是在JDK 1.3中引入的。schedule(TimerTask task, Date time)：该方法用于在指定时间执行指定的任务。schedule(TimerTask task, long delay)：该方法用于在指定延迟时间之后执行指定的任务。
《JAVA多线程编程核心技术》 笔记：第五章：定时器Timer
diangui9878的博客
08-26 67
一、定时器Timer的使用 1.1 方法schedule（TimerTask task， Date time） 是否过期 执行说明 开始执行时间 time>当前时间（未过期） 在time到达时执行 time（未被延期） time<当前时间（已过期） 当前时间立即执行 当前时间（被延...
《java多线程编程核心技术》读书笔记5：定时器Timer类的使用
GODBAR的博客
09-26 649
第5章：定时器Timer 在JDK库中，Timer类主要负责计划任务的功能，也就是在指定的时间开始执行某一任务，Timer类的主要任务就是设置计划任务，但封装任务 的类是TimerTask，执行计划任务的代码要放到TimerTask的子类中，因为TimerTask是一个抽象类。 Timer类的主要方法就是各种重载的schedule方法 schedule(TimerTask task,
Java多线程编程核心技术（第五章定时器Timer笔记）
sunxm1992的博客
01-24 270
1在JDK库中Timer类主要负责计划任务的执行，封装的任务类却是TimerTask类，执行任务的代码要放入TimerTask的子类中，因为TimerTask是一个抽象类。 2.用法：新建类集成TimerTask（）类，设置定时类private static Timer timer = new Timer(); 用法： package com.satx.thread; import jav
java多线程编写计时器,Java多线程编程核心技术-第5章-定时器 Timer-读书笔记
weixin_35218304的博客
03-21 145
第 5 章 定时器 Timer定时 / 计划功能在移动开发领域使用较多，比如 Android 技术。定时计划任务功能在 Java 中主要使用的就是 Timer 对象，他在内部使用多线程的方式进行处理，所以它和线程技术还是有非常大的关联的。本章主要内容如何实现指定时间执行任务。如何实现按指定周期执行任务。5.1 定时器 Timer 的使用在 JDK 库中 Timer 类主要负责计划任务的功能，也就是...
游戏编程学习笔记01 -- 定时器操作 代码附件
04-04
在游戏编程中，定时器（Timer）是一种至关重要的工具，它允许程序在特定的时间间隔执行特定的任务，这对于游戏循环、动画、用户输入响应等场景至关重要。在这个“游戏编程学习笔记01”中，我们将深入探讨如何在C++...
高手编程笔记 如何在Linux下实现定时器
09-14
在Linux系统中，实现定时器并不像Windows系统那样直接调用SetTimer函数，但Linux...选择哪种方法取决于具体的需求，如精度、多线程支持以及对系统资源的影响。在实际编程中，可以根据项目需求灵活选择和应用这些技术。
ServletContextListener,Timer,TimerTask学习笔记
05-25
需要注意的是，`Timer`的线程模型可能导致多个任务之间存在依赖关系时出现混乱，因此在多线程环境下使用时需谨慎。 结合`ServletContextListener`和`Timer`，可以在Web应用程序启动时创建一个定时器，用于定时执行...
JAVA画图形学程序(文+源代码).zip
03-27
8. **动画原理**：通过定时器（Timer类）或者多线程，可以实现图形的动态效果，如移动、旋转等。 源代码部分很可能是示例程序，涵盖上述概念的实际应用。这些示例可能包括简单的形状绘制、复杂图形的构建、交互式...
j3环视q111111
07-05
j3环视q111111
mysql cluster 8 linux 安装文件mysql cluster 8 linux 安装文件mysql cluste
07-05
mysql cluster 8 linux 安装文件mysql cluster 8 linux 安装文件mysql cluster 8 linux 安装文件mysql cluster 8 linux 安装文件mysql cluster 8 linux 安装文件
轿车车身的设计.doc
最新发布
07-05
轿车车身的设计.doc
Vue3-Watch、Watcheffect、Computed的使用和区别
07-05
Vue3--Watch、Watcheffect、Computed的使用和区别
VIC-Data-Share
04-07
2. Stm32Timer相关学习：讲解了STM32定时器的基础功能和实现原理，包括输入捕获模式用于测量频率，以及如何通过不同通道读取多个定时器。 3. 中断：区分了中断处理程序（handler）和回调函数的概念，讨论了如何利用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值