Java:定時啟動線程

這裡提供兩種在指定時間後啟動線程的方法。一是通過java.util.concurrent.DelayQueue實作；二是通過java.util.concurrent.ScheduledThreadPoolExecutor實作。

1. java.util.concurrent.DelayQueue

類DelayQueue是一個無界阻塞隊列，隻有在延遲期滿時才能從中提取元素。它接受實作Delayed接口的執行個體作為元素。

<<interface>>Delayed.java

package java.util.concurrent;

import java.util.*;

public interface Delayed extends Comparable<Delayed> {

    long getDelay(TimeUnit unit);

}

getDelay()傳回與此對象相關的剩餘延遲時間，以給定的時間機關表示。此接口的實作必須定義一個 compareTo 方法，該方法提供與此接口的 getDelay 方法一緻的排序。

DelayQueue隊列的頭部是延遲期滿後儲存時間最長的 Delayed 元素。當一個元素的getDelay(TimeUnit.NANOSECONDS) 方法傳回一個小于等于 0 的值時，将發生到期。

2.設計帶有時間延遲特性的隊列

類DelayedTasker維護一個DelayQueue<DelayedTask> queue，其中DelayedTask實作了Delayed接口，并由一個内部類定義。外部類和内部類都實作Runnable接口，對于外部類來說，它的run方法是按定義的時間先後取出隊列中的任務，而這些任務即内部類的執行個體，内部類的run方法定義每個線程具體邏輯。

這個設計的實質是定義了一個具有時間特性的線程任務清單，而且該清單可以是任意長度的。每次添加任務時指定啟動時間即可。

DelayedTasker.java

package com.zj.timedtask;

import static java.util.concurrent.TimeUnit.SECONDS;

import static java.util.concurrent.TimeUnit.NANOSECONDS;

import java.util.Collection;

import java.util.Collections;

import java.util.Random;

import java.util.concurrent.DelayQueue;

import java.util.concurrent.Delayed;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

public class DelayedTasker implements Runnable {

    DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();

    public void addTask(DelayedTask e) {

       queue.put(e);

    }

    public void removeTask() {

       queue.poll();

    public Collection<DelayedTask> getAllTasks() {

       return Collections.unmodifiableCollection(queue);

    public int getTaskQuantity() {

       return queue.size();

    public void run() {

       while (!queue.isEmpty())

           try {

              queue.take().run();

           } catch (InterruptedException e) {

              System.out.println("Interrupted");

           }

       System.out.println("Finished DelayedTask");

    public static class DelayedTask implements Delayed, Runnable {

       private static int counter = 0;

       private final int id = counter++;

       private final int delta;

       private final long trigger;

       public DelayedTask(int delayInSeconds) {

           delta = delayInSeconds;

           trigger = System.nanoTime() + NANOSECONDS.convert(delta, SECONDS);

       }

       public long getDelay(TimeUnit unit) {

           return unit.convert(trigger - System.nanoTime(), NANOSECONDS);

       public int compareTo(Delayed arg) {

           DelayedTask that = (DelayedTask) arg;

           if (trigger < that.trigger)

              return -1;

           if (trigger > that.trigger)

              return 1;

           return 0;

       public void run() {

           //run all that you want to do

           System.out.println(this);

       public String toString() {

           return "[" + delta + "s]" + "Task" + id;

    public static void main(String[] args) {

       Random rand = new Random();

       ExecutorService exec = Executors.newCachedThreadPool();

       DelayedTasker tasker = new DelayedTasker();

       for (int i = 0; i < 10; i++)

           tasker.addTask(new DelayedTask(rand.nextInt(5)));

       exec.execute(tasker);

       exec.shutdown();

結果：

[0s]Task 1

[0s]Task 2

[0s]Task 3

[1s]Task 6

[2s]Task 5

[3s]Task 8

[4s]Task 0

[4s]Task 4

[4s]Task 7

[4s]Task 9

Finished DelayedTask

3. java.util.concurrent.ScheduledThreadPoolExecutor

該類可以另行安排在給定的延遲後運作任務（線程），或者定期（重複）執行任務。在構造子中需要知道線程池的大小。最主要的方法是：

[1] schedule

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

建立并執行在給定延遲後啟用的一次性操作。

指定者：

-接口 ScheduledExecutorService 中的 schedule;

參數：

-command - 要執行的任務 ;

-delay - 從現在開始延遲執行的時間 ;

-unit - 延遲參數的時間機關 ;

傳回：

-表示挂起任務完成的 ScheduledFuture，并且其 get() 方法在完成後将傳回 null。

[2] scheduleAtFixedRate

public ScheduledFuture<?> scheduleAtFixedRate(

Runnable command,long initialDelay,long period,TimeUnit unit)

建立并執行一個在給定初始延遲後首次啟用的定期操作，後續操作具有給定的周期；也就是将在 initialDelay 後開始執行，然後在 initialDelay+period 後執行，接着在 initialDelay + 2 * period 後執行，依此類推。如果任務的任何一個執行遇到異常，則後續執行都會被取消。否則，隻能通過執行程式的取消或終止方法來終止該任務。如果此任務的任何一個執行要花費比其周期更長的時間，則将推遲後續執行，但不會同時執行。

-接口 ScheduledExecutorService 中的 scheduleAtFixedRate;

-initialDelay - 首次執行的延遲時間 ;

-period - 連續執行之間的周期 ;

-unit - initialDelay 和 period 參數的時間機關 ;

-表示挂起任務完成的 ScheduledFuture，并且其 get() 方法在取消後将抛出異常。

4.設計帶有時間延遲特性的線程執行者

類ScheduleTasked關聯一個ScheduledThreadPoolExcutor，可以指定線程池的大小。通過schedule方法知道線程及延遲的時間，通過shutdown方法關閉線程池。對于具體任務（線程）的邏輯具有一定的靈活性（相比前一中設計，前一種設計必須事先定義線程的邏輯，但可以通過繼承或裝飾修改線程具體邏輯設計）。

ScheduleTasker.java

import java.util.concurrent.ScheduledThreadPoolExecutor;

public class ScheduleTasker {

    private int corePoolSize = 10;

    ScheduledThreadPoolExecutor scheduler;

    public ScheduleTasker() {

       scheduler = new ScheduledThreadPoolExecutor(corePoolSize);

    public ScheduleTasker(int quantity) {

       corePoolSize = quantity;

    public void schedule(Runnable event, long delay) {

       scheduler.schedule(event, delay, TimeUnit.SECONDS);

    public void shutdown() {

       scheduler.shutdown();

       ScheduleTasker tasker = new ScheduleTasker();

       tasker.schedule(new Runnable() {

           public void run() {

              System.out.println("[1s]Task 1");

       }, 1);

              System.out.println("[2s]Task 2");

       }, 2);

              System.out.println("[4s]Task 3");

       }, 4);

              System.out.println("[10s]Task 4");

       }, 10);

       tasker.shutdown();

[1s]Task 1

[2s]Task 2

[4s]Task 3

[10s]Task 4

本文轉自zhangjunhd51CTO部落格，原文連結：http://blog.51cto.com/zhangjunhd/74646，如需轉載請自行聯系原作者