创建定时任务线程池的方式

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);// 不推荐
// 或
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(4);// 推荐

创建定时任务的方法

public interface ScheduledExecutorService extends ExecutorService {

    /**

     * 延迟delay（时间单位由unit指定）后执行任务

     *

     * @param command   任务

     * @param delay     延迟时间

     * @param unit      时间单位

     * @return          执行结果

     */

    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

    /**

     * 延迟delay（时间单位由unit指定）时间后执行任务

     * 任务执行完毕后，返回执行结果

     *

     * @param callable  任务

     * @param delay     延迟时间

     * @param unit      时间单位

     * @return          执行结果

     */

    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);

    /**

     * 延迟delay时间后执行第一次任务，之后每过period毫秒执行一次。

     * 假设:

     *      执行一次任务需要消耗的时间为 exeTime

     *      执行此次任务的开始时间是 nowTime

     *      执行下一次任务的实际时间是 actuallyTime

     * 如果 exeTime >= period ，那么，actuallyTime >= nowTime + exeTime;

     * 如果 exeTime < period ， 那么，actuallyTime >= nowTime + period;

     *

     * @param command       任务

     * @param initialDelay  执行首次任务之前的延时时间

     * @param period        周期性执行任务，相邻两次的时间间隔

     * @param unit          时间单位

     * @return              执行结果

     */

    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);

    /**

     * 延迟initialDelay时间后执行首次任务，之后的任务执行，全部在上次任务执行完毕之后，再延迟delay时间执行。

     *

     * 假设:

     *      执行一次任务需要消耗的时间为 exeTime

     *      执行此次任务的开始时间是 nowTime

     *      执行下一次任务的实际时间是 actuallyTime

     * 如果 exeTime >= period ，那么，actuallyTime >= nowTime + exeTime + delay;

     * 如果 exeTime < period ， 那么，actuallyTime >= nowTime + exeTime + period;

     *

     * @param command　　　　任务

     * @param initialDelay　执行首次任务之前的延迟时间

     * @param delay　　　　　每次任务执行完成后，执行下次任务之前的延迟时间

     * @param unit　　　　　　时间单位

     * @return

     */

    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

}

创建定时任务的示例

示例一：延迟执行

package com.java.scheduled.task.pool;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.ScheduledThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

public class ScheduledTaskDemo01 {

    public static void main(String[] args) {

        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(4);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date date = new Date();

        System.out.println("安排执行任务的时间："+sdf.format(date));

        long c1 = date.getTime();

        Runnable runnable = () -> {

            Date nowDate = new Date();

            System.out.println("****计划任务（1）：【延迟2秒执行】");

            System.out.println("实际执行任务的时间："+sdf.format(nowDate));

            System.out.println("延迟时间："+(nowDate.getTime() - c1)+"ms");

        };

        executorService.schedule(runnable, 2, TimeUnit.SECONDS);

    }

}

执行结果如下：

安排执行任务的时间：2019-05-28 12:10:46

****计划任务（1）：【延迟2秒执行】

实际执行任务的时间：2019-05-28 12:10:48

延迟时间：2087ms

示例二：延迟执行，返回结果

package com.java.scheduled.task.pool;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.concurrent.*;

public class ScheduledTaskDemo02 {

    public static void main(String[] args) {

        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date date = new Date();

        System.out.println("安排执行任务的时间："+sdf.format(date));

        long c2 = date.getTime();

        Callable<String> callable = () -> {

            Date nowDate = new Date();

            System.out.println("****计划任务（2）：【延迟2秒执行，执行结束返回结果】");

            System.out.println("实际执行任务的时间："+sdf.format(nowDate));

            System.out.println("延迟时间："+(nowDate.getTime() - c2)+"ms");

            Thread.sleep(1000);

            System.out.println("任务执行完毕，当前时间："+sdf.format(new Date()));

            return "success";

        };

        ScheduledFuture<String> scheduledFuture = executorService.schedule(callable, 2, TimeUnit.SECONDS);

        try {

            System.out.println("任务的执行结果："+scheduledFuture.get());

        } catch (ExecutionException e1) {

            e1.printStackTrace();

        } catch (InterruptedException e2) {

            e2.printStackTrace();

        }

    }

}

执行结果如下：

安排执行任务的时间：2019-05-28 12:14:05

****计划任务（2）：【延迟2秒执行，执行结束返回结果】

实际执行任务的时间：2019-05-28 12:14:07

延迟时间：2072ms

任务执行完毕，当前时间：2019-05-28 12:14:08

任务的执行结果：success

示例三：延迟+周期性执行任务

package com.java.scheduled.task.pool;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ScheduledTaskDemo03 {

    public static void main(String[] args) {

        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date date = new Date();

        System.out.println("安排执行任务的时间："+sdf.format(date));

        long c3 = date.getTime();

        Runnable runnable = new Runnable() {

            long exeTime = c3;

            @Override

            public void run() {

                Date nowDate = new Date();

                System.out.println("--------------------------------------------------------------------------------");

                System.out.println("计划任务（3）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】");

                System.out.println("****实际执行任务的时间："+sdf.format(nowDate));

                System.out.println("****距离上次执行任务的时间间隔："+(nowDate.getTime() - exeTime)+"ms");

                try {

                    Thread.sleep(4000);

                } catch (InterruptedException e) {}

                exeTime = nowDate.getTime();

            }

        };

        executorService.scheduleAtFixedRate(runnable, 1, 2, TimeUnit.SECONDS);

    }

}

执行结果如下：

安排执行任务的时间：2019-05-28 12:15:12

--------------------------------------------------------------------------------

计划任务（3）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:15:13

****距离上次执行任务的时间间隔：1003ms

--------------------------------------------------------------------------------

计划任务（3）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:15:17

****距离上次执行任务的时间间隔：4002ms

--------------------------------------------------------------------------------

计划任务（3）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:15:21

****距离上次执行任务的时间间隔：4001ms

--------------------------------------------------------------------------------

计划任务（3）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:15:25

****距离上次执行任务的时间间隔：4002ms

示例四：初始延迟+周期性延迟执行任务

package com.java.scheduled.task.pool;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ScheduledTaskDemo04 {

    public static void main(String[] args) {

        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date date = new Date();

        System.out.println("安排执行任务的时间："+sdf.format(date));

        long c3 = date.getTime();

        Runnable runnable = new Runnable() {

            long exeTime = c3;

            @Override

            public void run() {

                Date nowDate = new Date();

                System.out.println("--------------------------------------------------------------------------------");

                System.out.println("计划任务（4）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】");

                System.out.println("****实际执行任务的时间："+sdf.format(nowDate));

                System.out.println("****距离上次执行任务的时间间隔："+(nowDate.getTime() - exeTime)+"ms");

                try {

                    Thread.sleep(2500);

                } catch (InterruptedException e) {}

                exeTime = nowDate.getTime();

            }

        };

        executorService.scheduleWithFixedDelay(runnable, 1, 2, TimeUnit.SECONDS);

    }

}

执行结果如下：

安排执行任务的时间：2019-05-28 12:16:56

--------------------------------------------------------------------------------

计划任务（4）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:16:57

****距离上次执行任务的时间间隔：1018ms

--------------------------------------------------------------------------------

计划任务（4）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:17:01

****距离上次执行任务的时间间隔：4504ms

--------------------------------------------------------------------------------

计划任务（4）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:17:06

****距离上次执行任务的时间间隔：4502ms

--------------------------------------------------------------------------------

计划任务（4）：【延迟1秒执行第一次任务，之后每过2秒执行一次任务】

****实际执行任务的时间：2019-05-28 12:17:10

****距离上次执行任务的时间间隔：4502ms

最新文章

  1. 管道函数(%&gt;%)很简单
  2. Python补充05 字符串格式化 (%操作符)
  3. Ruby使用gets的错误：gets得到的有&#39;\n&#39;，需要使用chomp去掉
  4. 带你认识HTML5中的WebSocket
  5. How To Set Up Nginx Server Blocks (Virtual Hosts) on Ubuntu
  6. Linear Regreesion
  7. .PIG File
  8. 一个原生js写的加减乘除运算
  9. 解决eclipse中文字很小
  10. 产品经理学Python：逻辑判断与运算符
  11. 01_MyBatis EHCache集成及所需jar包,ehcache.xml配置文件参数配置及mapper中的参数配置
  12. 利用广度优先搜索(BFS)与深度优先搜索(DFS)实现岛屿个数的问题（java）
  13. word中编辑论文公式对齐问题
  14. Ultra-QuickSort POJ - 2299 （逆序对）
  15. sap 申请 新系统用户
  16. Doclever 接口mock 操作
  17. 这些JavaScript编程黑科技
  18. JAVA多线程和并发基础面试问答【转】
  19. 微信授权登录，关于调不起授权页面，无法响应回调方法，获取不到code 详解
  20. Java 权限框架 Shiro 实战一：理论基础

热门文章

  1. CNN中下一层Feature map大小计算
  2. Ubuntu 16.04上安装SkyEye及测试
  3. P2759 奇怪的函数
  4. CF 757E Bash Plays with Functions——积性函数+dp+质因数分解
  5. bzoj 1798 Seq 维护序列seq —— 线段树
  6. io_service work 的作用
  7. 使用httpClient下载网页
  8. UVaLive 3983 Robotruck (DP + 单调队列)
  9. codeforces 813C The Tag Game 树+dfs追击问题
  10. 《剑指offer面试题4》替换空格——实现函数把字符串中每个空格替换成“%20”