当前位置: 首页>>代码示例 >>用法及示例精选 >>正文

Java ScheduledThreadPoolExecutor用法及代码示例


Java中的ScheduledThreadPoolExecutor类是java.util.concurrent包中定义的ThreadPoolExecutor类的子类。从它的名字可以清楚地看出，当我们想要安排任务重复运行或在给定的延迟之后运行一段时间时，此类非常有用。它创建一个fixed-sized线程池。所以在启动时，需要给它 corePoolSize ( Thread pool 中的线程数)。

类层次结构：

ScheduledThreadPoolExecutor-Class-in-Java

构造函数：

  • ScheduledThreadPoolExecutor(int corePoolSize)：使用给定的池大小创建一个新的ScheduledThreadPoolExecutor对象。需要注意的是，它创建了一个 fixed-sized 线程池，因此一旦给出 corePoolSize，就无法增加线程池的大小。
  • ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)：使用给定参数创建一个新的ScheduledThreadPoolExecutor对象。第一个参数是线程池的大小，第二个参数是ThreadFactory 对象，当ScheduledThreadPoolExecutor 创建新线程时使用该对象。
  • ScheduledThreadPoolExecutor(int corePoolSize，RejectedExecutionHandler处理程序)：使用给定的 corePoolSize(ThreadPool size) 和任务执行被拒绝时(当工作队列已满或执行被阻止时)使用的处理程序创建一个新的 ScheduledThreadPoolExecutor 对象。
  • ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler 处理程序)：使用给定参数创建一个新的ScheduledThreadPoolExecutor对象。

除了这些构造函数之外，还有另一种获取 ScheduledThreadPoolExecutor 对象的方法。我们可以使用 Executors 类定义的 Executors.newScheduledThreadPool(int corePoolSize) 工厂方法。它返回一个ScheduledExecutorService对象，可以是type-casted到ScheduledThreadPoolExecutor对象。

ScheduledThreadPoolExecutor threadPool = (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(4);

示例 1：

Java 


// Java program to demonstrates ScheduleThreadPoolExecutor 
// class 
import java.util.*; 
import java.util.concurrent.*; 
import java.io.*; 
  
class GFG { 
    public static void main(String[] args) 
    { 
  
        // Creating a ScheduledThreadPoolExecutor object 
        ScheduledThreadPoolExecutor threadPool 
            = new ScheduledThreadPoolExecutor(2); 
  
        // Creating two Runnable objects 
        Runnable task1 = new Command("task1"); 
        Runnable task2 = new Command("task2"); 
  
        // Printing the current time in seconds 
        System.out.println( 
            "Current time : "
            + Calendar.getInstance().get(Calendar.SECOND)); 
  
        // Scheduling the first task which will execute 
        // after 2 seconds 
        threadPool.schedule(task1, 2, TimeUnit.SECONDS); 
  
        // Scheduling the second task which will execute 
        // after 5 seconds 
        threadPool.schedule(task2, 5, TimeUnit.SECONDS); 
  
        // Remember to shut sown the Thread Pool 
        threadPool.shutdown(); 
    } 
} 
  
// Class that implements the Runnable interface 
class Command implements Runnable { 
    String taskName; 
    public Command(String taskName) 
    { 
        this.taskName = taskName; 
    } 
    public void run() 
    { 
        System.out.println( 
            "Task name : " + this.taskName + " Current time: "
            + Calendar.getInstance().get(Calendar.SECOND)); 
    } 
}

输出：

Current time : 51
Task name : task1 Current time : 53
Task name : task2 Current time : 56

这里第一个任务在两秒延迟后执行，第二个任务在五秒后执行。

示例 2：

Java 


// Java program to demonstrates ScheduleThreadPoolExecutor 
// class 
import java.util.*; 
import java.util.concurrent.*; 
import java.io.*; 
  
class GFG { 
    public static void main(String[] args) 
    { 
  
        // Creating a ScheduledThreadPoolExecutor object 
        ScheduledThreadPoolExecutor threadPool 
            = new ScheduledThreadPoolExecutor(2); 
  
        // Creating two Runnable objects 
        Runnable task1 = new Command("task1"); 
        Runnable task2 = new Command("task2"); 
  
        // Printing the current time in seconds 
        System.out.println( 
            "Current time:"
            + Calendar.getInstance().get(Calendar.SECOND)); 
  
        // Scheduling the first task which will execute 
        // after 2 seconds and then repeats periodically with 
        // a period of 8 seconds 
        threadPool.scheduleAtFixedRate(task1, 2, 8, 
                                       TimeUnit.SECONDS); 
  
        // Scheduling the second task which will execute 
        // after 5 seconds and then there will be a delay of 
        // 5 seconds between the completion 
        // of one execution and the commencement of the next 
        // execution 
        threadPool.scheduleWithFixedDelay(task2, 5, 5, 
                                          TimeUnit.SECONDS); 
  
        // Wait for 30 seconds 
        try { 
            Thread.sleep(30000); 
        } 
        catch (Exception e) { 
            e.printStackTrace(); 
        } 
  
        // Remember to shut sown the Thread Pool 
        threadPool.shutdown(); 
    } 
} 
  
// Class that implements Runnable interface 
class Command implements Runnable { 
    String taskName; 
    public Command(String taskName) 
    { 
        this.taskName = taskName; 
    } 
    public void run() 
    { 
        try { 
            System.out.println("Task name : "
                               + this.taskName 
                               + " Current time : "
                               + Calendar.getInstance().get( 
                                     Calendar.SECOND)); 
            Thread.sleep(2000); 
            System.out.println("Executed : " + this.taskName 
                               + " Current time : "
                               + Calendar.getInstance().get( 
                                     Calendar.SECOND)); 
        } 
        catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
}

输出：

Current time:26
Task name : task1 Current time : 28
Executed : task1 Current time : 30
Task name : task2 Current time : 31
Executed : task2 Current time : 33
Task name : task1 Current time : 36
Executed : task1 Current time : 38
Task name : task2 Current time : 38
Executed : task2 Current time : 40
Task name : task1 Current time : 44
Task name : task2 Current time : 45
Executed : task1 Current time : 46
Executed : task2 Current time : 47
Task name : task1 Current time : 52
Task name : task2 Current time : 52
Executed : task1 Current time : 54
Executed : task2 Current time : 54

在这里，第一个任务将在两秒后执行，然后在八秒后定期重复。第二个任务将在五秒后执行，然后在一次执行完成和下一次执行开始之间会有五秒的延迟。

方法

METHOD

DESCRIPTION
DecorateTask(Callable<V> 可调用，RunnableScheduledFuture<V> 任务) 修改或替换用于执行可调用的任务。
decorateTask(Runnable 可运行，RunnableScheduledFuture<V> 任务) 修改或替换用于执行可运行的任务。
execute(Runnable command) 以零所需延迟执行命令。
getContinueExistingPeriodicTasksAfterShutdownPolicy( ) 获取即使该执行器已关闭也是否继续执行现有定期任务的策略。
getExecuteExistingDelayedTasksAfterShutdownPolicy( ) 获取即使该执行器已关闭是否仍执行现有延迟任务的策略。
getQueue() 返回此执行器使用的任务队列。
getRemoveOnCancelPolicy() 获取有关取消的任务是否应在取消时立即从工作队列中删除的策略。
调度(Callable<V> 可调用，长延迟，TimeUnit 单元) 创建并执行在给定延迟后启用的ScheduledFuture。
schedule(Runnable command, long delay, TimeUnit unit) 创建并执行 one-shot 操作，该操作在给定延迟后启用。
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建并执行一个周期性操作，该操作首先在给定的延迟之后启用，然后在给定的时间段内启用。
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行一个周期性操作，该操作在给定的延迟之后启用，并随后在一次执行终止和下一次执行开始之间具有给定的延迟。
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) 设置即使该执行器已关闭也是否继续执行现有定期任务的策略。
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) 设置即使该执行器已关闭也是否执行现有延迟任务的策略。
setRemoveOnCancelPolicy() 设置取消任务时是否应立即从工作队列中删除的策略。
shutdown() 启动有序关闭，执行先前提交的任务，但不会接受新的任务。
shutdownNow() 尝试停止所有正在执行的任务会停止正在等待的任务的处理，并返回正在等待执行的任务的列表。
提交(Callable<T> 任务) 提交一个返回值的任务以供执行，并返回一个表示任务待处理结果的 future。
submit(Runnable task) 提交一个可运行的任务以供执行，并返回代表该任务的 future。
submit(Runnable task, T result) 提交一个可运行的任务以供执行，并返回代表该任务的 future。


相关用法


注：本文由纯净天空筛选整理自samufo大神的英文原创作品 ScheduledThreadPoolExecutor Class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。