Java并发——ScheduledExecutorService

最新推荐文章于 2024-08-06 09:40:24 发布
最新推荐文章于 2024-08-06 09:40:24 发布
阅读量2.8k 收藏 1
点赞数 3
分类专栏： 并发编程 文章标签： Java 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/106948959
版权

ScheduledExecutorService

类 Scheduledexecutor Service的主要作用就是可以将定时任务与线程池功能结合使用。
在这里插入图片描述

ScheduledThreadPoolExecutor使用Callable延迟运行
public class MyCallableAA implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            System.out.println("callA begin " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            Thread.sleep(3000);
            System.out.println("callA end " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "returnA";
    }
}



public class MyCallableBB implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("callB begin " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        System.out.println("callB end " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        return "returnB";
    }
}


public class MyRun1 {
    public static void main(String[] args) {
        try {
            List<Callable> callables = new ArrayList<>();
            callables.add(new MyCallableAA());
            callables.add(new MyCallableBB());
            //调用方法newSingleThreadScheduledExecutor()，取得一个单任务的计划任务执行池
            ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
            ScheduledFuture<String> futureA = executorService.schedule(callables.get(0), 4L, TimeUnit.SECONDS);
            ScheduledFuture<String> futureB = executorService.schedule(callables.get(1), 4L, TimeUnit.SECONDS);

            System.out.println("     X=" + System.currentTimeMillis());
            System.out.println("返回值A：" + futureA.get());
            System.out.println("返回值B：" + futureB.get());
            System.out.println("     Y=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

从X到Y的运行时间为7秒，阻塞点是get()方法。
从运行结果中可以发现：public <V> Scheduled Future<V> schedule(Callable<v> callable, long delay, Time Unit unit)
方法中的第2个参数在多个任务中同时消耗时间,并不是一个任务执行完毕后再等待4秒继续执行的效果。由于第1个任务从计划任务到运行结束需要用时7秒,那么第2个任务其实是想在第4秒被执行,由于是单任务的计划任务池,所以第2个任务的执行时间被延后3秒。
在这里插入图片描述

在此实验中使用工厂类 Executors的 newSingleThreadScheduledExecutor方法来创建
ScheduledExecutorService对象,但返回的真正对象却是 Scheduledthreadpoolexecutor,因为
Scheduled Thread PoolExecutor实现了ScheduledexecutorService接口。
在这里插入图片描述

ScheduledThreadPoolExecutor使用Runnable延迟运行
public class MyRunnableAA implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("runnableA begin " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            Thread.sleep(3000);
            System.out.println("runnableA end " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class MyRunnableBB implements Runnable {
    @Override
    public void run() {
        System.out.println("runnableB begin " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        System.out.println("runnableB end " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
    }
}

public class MyRun2 {
    public static void main(String[] args) {
        List<Runnable> list = new ArrayList<>();
        list.add(new MyRunnableAA());
        list.add(new MyRunnableBB());
        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();

        System.out.println("     X=" + System.currentTimeMillis());
        executorService.schedule(list.get(0), 0L, TimeUnit.SECONDS);
        executorService.schedule(list.get(1), 1L, TimeUnit.SECONDS);
        System.out.println("     Y=" + System.currentTimeMillis());
    }
}

在这里插入图片描述

延迟运行并取得返回值
public class MyRun3 {
    public static void main(String[] args) {
        Callable<String> callable = new Callable<String>() {
            public String call() throws Exception {
                System.out.println("a call run =" + System.currentTimeMillis());
                return "returnA";
            }
        };

        try {
            List<Callable> list = new ArrayList<>();
            list.add(callable);
            ScheduledExecutorService exector = Executors.newSingleThreadScheduledExecutor();
            System.out.println("     X=" + System.currentTimeMillis());
            ScheduledFuture future = exector.schedule(list.get(0), 4L, TimeUnit.SECONDS);
            System.out.println(future.get() + "    A=" + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

使用scheduleAtFixedRate()方法实现周期性执行
  • command：执行线程
  • initialDelay：初始化延时
  • period：两次开始执行最小间隔时间
  • unit：计时单位

执行任务时间大于>period预定的周期时间，也就是产生了超时的效果：

public class MyRun4 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("   begin=" + System.currentTimeMillis() +
                            " ThreadName=" + Thread.currentThread().getName());
                    Thread.sleep(4000);
                    System.out.println("   end=" + System.currentTimeMillis() +
                            " ThreadName=" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        System.out.println("  X=" + System.currentTimeMillis());
        executor.scheduleAtFixedRate(runnable, 1, 2, TimeUnit.SECONDS);
        System.out.println("  Y=" + System.currentTimeMillis());
    }
}

任务执行时间(4)大于周期时间(2)，所以产生超时效果，每次执行任务不再间隔2秒。
在这里插入图片描述

执行任务时间<period的时间：

public class MyRun5 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("  begin=" + System.currentTimeMillis() +
                        " ThreadName=" + Thread.currentThread().getName());
                System.out.println("  end=" + System.currentTimeMillis() +
                        " ThreadName=" + Thread.currentThread().getName());
            }
        };

        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        System.out.println("  X=" + System.currentTimeMillis());
        executor.scheduleAtFixedRate(runnable, 1, 2, TimeUnit.SECONDS);
        System.out.println("  Y=" + System.currentTimeMillis());
    }
}

每次间隔2秒执行。
在这里插入图片描述

注意: scheduleAtFixedRatel方法返回的 Scheduled
Future对象无法获得返回值,也就是scheduleAtFixedRate()方法不具有获得返回值的功能,而 schedule方法却可以获得返回值。所以当使用 scheduleAtFixedRate方法实现重复运行任务的效果时,需要结合自定义 Runnable接口的实现类，不要使用FutureTask类，因为FutureTask类并不能实现重复运行的效果。

使用scheduleWithFixedDelay()方法实现周期性执行

方法 schedule With FixedDelay(的主要作用是设置多个任务之间固定的运行时间间隔。

执行任务时间大于> period定的时间

public class MyRun6 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("  begin=" + System.currentTimeMillis() +
                            " ThreadName=" + Thread.currentThread().getName());
                    Thread.sleep(4000);
                    System.out.println("  end=" + System.currentTimeMillis() +
                            " ThreadName=" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        System.out.println("  X=" + System.currentTimeMillis());
        executor.scheduleWithFixedDelay(runnable, 1, 2, TimeUnit.SECONDS);
        System.out.println("  Y=" + System.currentTimeMillis());
    }
}

固定每隔2秒执行一次。
在这里插入图片描述

执行任务时间<period：

public class MyRun6 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("  begin=" + System.currentTimeMillis() +
                        " ThreadName=" + Thread.currentThread().getName());
                System.out.println("  end=" + System.currentTimeMillis() +
                        " ThreadName=" + Thread.currentThread().getName());
            }
        };

        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        System.out.println("  X=" + System.currentTimeMillis());
        executor.scheduleWithFixedDelay(runnable, 1, 2, TimeUnit.SECONDS);
        System.out.println("  Y=" + System.currentTimeMillis());
    }
}

固定每隔2秒执行一次。
在这里插入图片描述

getQueue()与remove()方法

方法 getQueue()的作用是取得队列中的任务,而这些任务是未来将要运行的,正在运行的任务不在此队列中。使用 scheduleAtFixedRateO和 scheduleWithFixedDelay()两个方法实现周期性执行任务时,未来欲执行的任务都是放入此队列中。

public class MyRun7 {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);

        Runnable_A r1 = new Runnable_A("A");
        Runnable_A r2 = new Runnable_A("B");
        Runnable_A r3 = new Runnable_A("C");
        Runnable_A r4 = new Runnable_A("D");
        Runnable_A r5 = new Runnable_A("E");

        System.out.println(r1.hashCode());
        System.out.println(r2.hashCode());
        System.out.println(r3.hashCode());
        System.out.println(r4.hashCode());
        System.out.println(r5.hashCode());

        executor.scheduleAtFixedRate(r1, 10, 2, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(r2, 10, 2, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(r3, 10, 2, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(r4, 10, 2, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(r5, 10, 2, TimeUnit.SECONDS);

        System.out.println("");

        BlockingQueue<Runnable> queue = executor.getQueue();
        Iterator<Runnable> it = queue.iterator();
        while (it.hasNext()) {
            Runnable next = it.next();
            System.out.println("队列中的：" + next);
        }
    }
}

class Runnable_A implements Runnable {
    private String username;

    public Runnable_A(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

    @Override
    public void run() {
        System.out.println("run! username=" + Thread.currentThread().getName());
    }
}

在这里插入图片描述

public class MyRun7 {
    public static void main(String[] args) throws InterruptedException {
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);

        Runnable_A r1 = new Runnable_A("A");
        Runnable_A r2 = new Runnable_A("B");

        ScheduledFuture<?> future1 = executor.scheduleAtFixedRate(r1, 0, 2, TimeUnit.SECONDS);
        Thread.sleep(1000);
        ScheduledFuture<?> future2 = executor.scheduleAtFixedRate(r2, 10, 2, TimeUnit.SECONDS);
        Thread.sleep(5000);
        System.out.println(executor.remove((Runnable) future2));
        System.out.println("");

        BlockingQueue<Runnable> queue = executor.getQueue();
        Iterator<Runnable> it = queue.iterator();
        while (it.hasNext()) {
            Runnable next = it.next();
            System.out.println("队列中的:" + next);
        }
    }
}

class Runnable_A implements Runnable {
    private String username;

    public Runnable_A(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

    @Override
    public void run() {
        System.out.println("run! username=" + Thread.currentThread().getName());
    }
}

在这里插入图片描述

setExecuteExistingDelayedTasksAfterShtudownPolicy()

方法 setExecuteExisting DelayedTasksAfterShutdownPolicy()的作用是当对 ScheduledThreadPoolExecutor执行了shutdown方法时,任务是否继续运行,默认值是true,也就是
当调用了 shutdown方法时任务还是继续运行,当使用 set ExecuteExistingDelayedTasksAfterShutdownPolicy(alse)时任务不再运行。

public class MyRun8 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("任务执行！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
        executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
        executor.schedule(runnable, 3, TimeUnit.SECONDS);
        executor.shutdown();
        System.out.println("main end");
    }
}

在这里插入图片描述

注意：方法setExecuteExistingDelayedTasksAfterShutdownPolicy可以与 schedule()和 shutdown()方法联合使用,但 setExecuteExistingDelayedTasksAfterShutdownPolicy()方法不能与 scheduleatFixedRate()和 scheduleWithFixedDelay()方法联合使用。

那么如果想实现 shutdown关闭线程池后,池中的任务还会继续重复运行,则要将 scheduleatFixedRate和 scheduleWithFixedDelayo方法与 setContinueExistingPeriodicTasksAfterShutdownPolicy()方法联合使用。

setContinueExistingPeriodicTasksAfterShutdownPolicy()

方法 setContinueExistingPeriodicTasksAfterShutdownPolicy()传入tue的作用是当使用 scheduleAtFixedRate()方法或 scheduleWithFixedDelay()方法时,如果调用 ScheduledThreadPoolExecutor对象的 shutdown()方法,任务还会继续运行,传入false时任务不运行,进程销毁。

public class MyRun8 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("任务执行！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
        executor.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
        executor.scheduleWithFixedDelay(runnable, 0,3, TimeUnit.SECONDS);
        executor.shutdown();
        System.out.println("main end");
    }
}

在这里插入图片描述

cancel(boolean)与setRemoveOnCancelPolicy()
  • 方法 cancel(boolean)的作用设定是否取消任务。
  • 方法 setRemove On CancelPolicy (boolean)的作用设定是否将取消后的任务从队列中清除。
public class MyRun9 {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
        Runnable runnable1 = new Runnable_B("A");
        ScheduledFuture<?> future = executor.schedule(runnable1, 1, TimeUnit.SECONDS);
        System.out.println(future.cancel(true));
        System.out.println("");
        BlockingQueue<Runnable> queue = executor.getQueue();
        Iterator<Runnable> it = queue.iterator();
        while (it.hasNext()) {
            Runnable next = it.next();
            System.out.println("队列中的：" + next);
        }
        System.out.println("main end");
    }
}

class Runnable_B implements Runnable {

    private String username;

    public Runnable_B(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public void run() {
        try {
            while (true) {
                if (Thread.currentThread().isInterrupted() == true) {
                    throw new InterruptedException();
                }
                System.out.println("run! username=" + username + " " + Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("中断了！");
        }
    }
}

删除成功，但是还保留在队列中。
在这里插入图片描述

在这里插入图片描述
删除成功，从队列中剔除。
在这里插入图片描述

吴声子夜歌
关注
专栏目录
深入探索 Java 中的定时任务调度工具：ScheduledExecutorService
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
12-28 1194
在Java开发中，任务调度对于应用程序的稳定性和效率至关重要。ScheduledExecutorService作为Java提供的一个强大工具，能够让开发者轻松管理和执行定时任务。本文将深入探讨ScheduledExecutorService的用法、语法结构、示例代码以及最佳实践，旨在帮助开发者更好地利用这一功能，优化任务的调度和执行，以确保应用程序的顺畅运行。
【项目实战】并发编程之ScheduledExecutorService，Java提供的一个定时任务框架
本本本添哥
04-17 477
ScheduledExecutorService是Java提供的一个定时任务框架它可以用于调度任务的执行时间和频率。在Java中，ScheduledExecutorService是一个接口，ScheduledThreadPoolExecutor是它的一个实现类。ScheduledThreadPoolExecutor提供了一些额外的功能可以设置线程池的大小可以设置任务的超时时间等。如果您需要使用这些额外的功能，可以使用ScheduledThreadPoolExecutor。
【Java】定时器ScheduledExecutorService
qq_53070263的博客
02-23 4050
ScheduledExecutorService是一个定时器，可以用来将任务安排在指定的时间后执行，或者周期性的执行一个任务。
ScheduledExecutorService：Java 中的定时任务调度
最新发布
故事不长丨的博客
08-06 921
ScheduledExecutorService` 是 Java 并发包 `java.util.concurrent` 中的一个接口，它继承自 `ExecutorService`，提供了定时执行任务的能力。通过 `ScheduledExecutorService`，你可以安排任务在延迟后执行，或者周期性地执行。
Java调度线程池ScheduleExecutorService
weixin_30586257的博客
02-19 367
如果在一个ScheduleExecutorService中提交一个任务，这个任务的调度周期设置 的时间比任务本身执行的时间短的话会出现什么情况？也就是在线程调度时间已经到了 但是上次的任务还没有做完的情况下，ScheduleExecutorService是怎么处理的？ 这个问题曾经困扰了我很久，我们都知道，ScheduleExecutorService是一个支持周期调度的...
ScheduledExecutorService
Cages的专栏
02-28 180
  先来个传统的Timer的例子：   package com.jerry.concurrency; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTa...
Java ScheduledExecutorService
cxmfzu的博客
08-21 590
ScheduledExecutorService 简介 ScheduledExecutorService 的主要功能是将定时任务与线程池结合使用，网络上有很多博客对ScheduledExecutorService进行了分析，同时与Timer进行的比对。因此本篇不在对此进行描述，本篇主要描述使用ScheduledExecutorService的注意事项。 ScheduledExecutorService 代码原型 ScheduledExecutorService的构造函数源码是 public Schedule
java面试——南京-软通动力-Java中级.zip
09-26
在Java中级面试中，软通动力作为一家知名的IT服务企业，通常会关注应聘者对Java基础知识、编程实践、设计模式以及并发处理等多方面的能力。这份资料“java面试——南京-软通动力-Java中级.zip”包含了一份详细的PDF...
08.Java多线程、并发——原理
跑了个调的博客
09-14 799
java多线程、并发知识
Java并发编程（5）—— Java线程池
shangjg3的博客
11-05 123
上面线程池分类中的 newSingleThreadScheduledExecutor() 和 newScheduledThreadPool() 都可以用于创建支持定时任务的线程池，它们返回的都是 ScheduledExecutorService 接口的实例。newSingleThreadExecutor()： 该方法返回一个只有一个线程的线程池。若多个任务被提交到该线程池，则多余的任务会被保存在一个任务队列中，待线程空闲，按照先入先出的顺序被执行。如果所有线程均处于工作状态，则会创建新的线程来进行处理。
Java 并发编程：Java 线程池的介绍与使用
栗筝i的博客
08-02 3690
内存泄漏的标准定义是当应用程序不再使用对象时发生的情况，但是垃圾回收器无法将其从工作内存中删除，因为它们仍在被引用。因此，应用程序会消耗越来越多的资源，最终导致致命的。垃圾回收操作需要消耗 CPU、线程、时间等资源，所以容易理解的是垃圾回收操作不是实时发生，当内存消耗完或者是达到某一个指标，才能触发垃圾回收操作。在 JVM 堆中，有两种类型的对象——引用和未引用，垃圾回收器可以删除未被引用的对象。即使不再被应用程序使用，也不会收集被引用的对象。
Java定时任务-ScheduledExecutorService
weixin_43911286的博客
01-27 1199
1.ScheduledExecutorService的接口介绍 package java.util.concurrent; public interface ScheduledExecutorService extends ExecutorService { //单次执行，在指定延时delay后运行command任务 public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);
ScheduleExecutorService,周期性线程池
wytwyt123456的专栏
02-28 942
ScheduleExecutorService1.按指定频率周期执行某个任务。初始化延迟0ms开始执行，每隔100ms重新执行一次任务。[java] view plain copy/**  * 以固定周期频率执行任务  */  public static void executeFixedRate() {      ScheduledExecutorService executor = Execu...
03_java内置线程池(ScheduledExecutorService)
w7635122886的博客
02-09 424
java内置线程池(ScheduledExecutorService)
ScheduledExecutorService详解
Mr朱鹏的博客
05-14 1411
ScheduledExecutorService详解
ScheduledExecutorService 延迟 / 周期执行线程池
热门推荐
蚩尤后裔-汪茂雄
06-28 5万+
目录 Executor 结构图 ScheduleExecutorService 简述 对象创建方式 方法详解 schedule Runnable schedule Callable scheduleAtFixedRate scheduleWithFixedDelay 本文可参考《线程池理论 2》 Executor 结构图 ScheduleExecutorService...
Java多线程的ScheduledExecutorService使用
qq_1763467007的博客
04-04 8427
ScheduledExecutorService使用（一）定时任务的几种方案介绍（二）ScheduledExecutorService介绍（三）ScheduledExecutorService的使用3.1 schedule()使用 （一）定时任务的几种方案介绍 使用java做一个后台的定时任务，方案可以有如下几种： 1、JDK自带的Timer 2、JDK1.5+ 新增的ScheduledExecutorService 3、Quartz ：简单却强大的JAVA作业调度框架，可以支持动态的Cron语法 （二）S
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值