Java多线程问题--schedule函数和scheduleAtFixedRate的用法和区别

本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！

代码地址：https://github.com/xianzhixianzhixian/thread.git

schedule函数和scheduleAtFixedRate的用法和区别

1、schedule(TimerTask task, Date time)的作用

在指定的时间执行任务，如果指定时间早于当前时间则立即执行任务，如果指定时间晚于当前时间则等待到指定时间再执行任务

2、TimerTask类中的cancel()的作用

TimerTask的cancel()方法cancel()方法作用是将自身从任务队列中清除，其它任务不受影响

3、Timer类的cancel()的作用

Timer类中的cancel()方法的作用是将任务队列中的全部任务清空，但是会存在失效的情况，因为timer.cancel()无法获得queue的锁，源码所示

4、schedule(TimerTask task, long delay)的作用

以当前时间为参考，在此时间基础上延迟指定时间的毫秒数后执行一次TimerTask任务

5、schedule(TimerTask task, Date firstTime, long period)的作用

在指定日期之后，按指定的间隔周期性地无限地执行某一任务

6、schedule(TimerTask task,long delay,long period)的作用

以当前时间为参考，在此时间基础上延迟指定毫秒数，再以某一时间间隔无限次数地执行某一任务

7、TimerTask是以队列方式一个一个被顺序执行的，并且是线程安全的

8、schedule方法任务延时时：下一次运行开始的时间是上一个任务的结束时间。schedule方法任务不延时时：下一次运行开始的时间是以上一个任务开始的时间加上period时间。scheduleAtFixedRate延时：下一个任务的开始时间是上一个任务的结束时间。scheduleAtFixedRate不延时时：下一个任务的开始时间是上一个任务的结束时间（上一次任务的开始时间加上delay时间，此处delay时间为run()函数中的Thread.sleep()的时间）。

9、schedule方法不具有追赶性，scheduleAtFixedRate方法具有追赶性。个人理解：不具有追赶性的意思是上一个任务执行完毕后（不延时），下一个任务的开始时间为上一个任务的开始时间加上period时间，两个时间段之间的任务被取消了。具有追赶性的意思是上一个任务执行完毕后（不延时），下一个任务的开始时间为上一个任务的结束时间。

schedule函数和scheduleAtFixedRate的示例

不延迟时

ScheduleNotDelay.java

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

/**
 * 测试schedule方法任务不延时
 * 下一次运行开始的时间是以上一个任务开始的时间加上period时间
 * @author: xianzhixianzhixian
 * @date: 2019-02-13 22:09
 */
public class ScheduleNotDelay {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了！时间为："+new Date());
                Thread.sleep(1000);
                System.out.println("1 end 运行了！时间为："+new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            MyTask task = new MyTask();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-02-13 15:11:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串1时间："+dateRef.toLocaleString()+" 当前时间："
                        +new Date().toLocaleString());
            timer.schedule(task, dateRef, 4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：schedule方法任务不延时，下一次运行开始的时间是以上一个任务开始的时间加上period时间

ScheduleAtFixedRateNotDelay.java

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

/**
 * 测试scheduleAtFixedRate不延时
 * 下一个任务的开始时间是上一个任务的结束时间（上一次任务的开始时间加上delay时间，此处delay时间为run()函数中的Thread.sleep()的时间）
 * @author: xianzhixianzhixian
 * @date: 2019-02-13 22:24
 */
public class ScheduleAtFixedRateNotDelay {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了！时间为："+new Date());
                Thread.sleep(1000);
                System.out.println("1 end 运行了！时间为："+new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            MyTask task = new MyTask();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-02-13 22:33:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串1时间："+dateRef.toLocaleString()+" 当前时间："
                    +new Date().toLocaleString());
            timer.scheduleAtFixedRate(task, dateRef, 4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：scheduleAtFixedRate不延时，下一个任务的开始时间是上一个任务的结束时间（上一次任务的开始时间加上delay时间，此处delay时间为run()函数中的Thread.sleep()的时间）

延迟时

ScheduleDelay.java

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

/**
 * 测试schedule方法任务延时
 * 下一次运行开始的时间是上一个任务的结束时间
 * @author: xianzhixianzhixian
 * @date: 2019-02-13 22:18
 */
public class ScheduleDelay {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了！时间为："+new Date());
                Thread.sleep(5000);
                System.out.println("1 end 运行了！时间为："+new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            MyTask task = new MyTask();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-02-13 15:11:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串1时间："+dateRef.toLocaleString()+" 当前时间："
                    +new Date().toLocaleString());
            timer.schedule(task, dateRef, 4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：schedule方法任务延时，下一次运行开始的时间是上一个任务的结束时间

ScheduleAtFixedRateDelay.java

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

/**
 * 测试scheduleAtFixedRate延时
 * 下一个任务的开始时间是上一个任务的结束时间
 * @author: xianzhixianzhixian
 * @date: 2019-02-13 22:24
 */
public class ScheduleAtFixedRateDelay {
    private static Timer timer = new Timer();
    private static int runCount = 0;
    static public class MyTask extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("1 begin 运行了！时间为："+new Date());
                Thread.sleep(5000);
                System.out.println("1 end 运行了！时间为："+new Date());
                runCount++;
                if (runCount == 5) {
                    timer.cancel();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            MyTask task = new MyTask();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = "2019-02-13 15:11:00";
            Date dateRef = sdf.parse(dateString);
            System.out.println("字符串1时间："+dateRef.toLocaleString()+" 当前时间："
                    +new Date().toLocaleString());
            timer.scheduleAtFixedRate(task, dateRef, 4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：scheduleAtFixedRate延时，下一个任务的开始时间是上一个任务的结束时间