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 bean) {
       queue.add(bean);
    }
 
    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().doLogic();
           } catch (InterruptedException e) {
              System.out.println("Interrupted");
           }
       System.out.println("Finished DelayedTask");
    }

package com.jshx.common.thread.utils;

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

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * <p></p>
 *
 * @author : duanpf
 * @version : 1.0
 * @date : 2009-5-21 9:15:34
 */
public abstract class DelayBean implements Delayed
{
    public final long delta;

    public DelayBean()
    {
        this(0);
    }

    public DelayBean(long delayTime)
    {
        this(delayTime, SECONDS);
    }

    public DelayBean(long delayTime, TimeUnit unit)
    {
        delta = System.nanoTime() + NANOSECONDS.convert(delayTime, unit);
    }

    public long getDelay(TimeUnit unit)
    {
        return unit.convert(delta - System.nanoTime(), NANOSECONDS);
    }

    public int compareTo(Delayed o)
    {
        DelayBean that = (DelayBean) o;
        if (delta < that.delta)
        {
            return -1;
        }
        if (delta > that.delta)
        {
            return 1;
        }
        return 0;
    }

    public abstract void doLogic() throws Exception;
}

 
    public static class DelayedTask extends DelayBean {
 
       public void doLogic() {
           //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


二、线程池
ThreadPoolExecutor中策略的选择与工作队列的选择（java线程池）
工作原理

1、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。

2、当调用 execute() 方法添加一个任务时，线程池会做如下判断：

       a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；

　　 b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。

　　 c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；



　　 d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。

3、当一个线程完成任务时，它会从队列中取下一个任务来执行。

4、当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

　 　这样的过程说明，并不是先加入任务就一定会先执行。假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4~13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务 17~20 则会抛出异常。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。下面是一个线程池使用的例子：

排队
所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：
  •如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。
  •如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。
  •如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。
排队有三种通用策略：
  1.直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  2.无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  3.有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。


被拒绝的任务
  当 Executor 已经关闭，并且 Executor 将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法 execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下，execute 方法都将调用其RejectedExecutionHandler的RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：
  1.在默认的 ThreadPoolExecutor.AbortPolicy 中，处理程序遭到拒绝将抛出运行时RejectedExecutionException。
  2.在 ThreadPoolExecutor.CallerRunsPolicy 中，线程调用运行该任务的execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
  3.在 ThreadPoolExecutor.DiscardPolicy 中，不能执行的任务将被删除。
  4.在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

定义和使用其他种类的 RejectedExecutionHandler 类也是可能的，但这样做需要非常小心，尤其是当策略仅用于特定容量或排队策略时。

公用的类ThreadPoolTask

public class ThreadPoolTask implements Runnable { 
  // 保存任务所需要的数据 
  private Object threadPoolTaskData; 
  private static int consumerTaskSleepTime = 2000; 

  ThreadPoolTask(Object tasks) { 
    this.threadPoolTaskData = tasks; 
  } 

  public void run() { 
    // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句 
    System.out.println("start .." + threadPoolTaskData); 
    try { 
      //便于观察，等待一段时间 
      Thread.sleep(consumerTaskSleepTime); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    System.out.println("finish " + threadPoolTaskData); 
    threadPoolTaskData = null; 
  } 

} 

ThreadPoolExecutor.AbortPolicy

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果：

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
put task@ 4
start ..task@ 2
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 7
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
put task@ 9
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
put task@ 10
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
finish task@ 2
finish task@ 6
finish task@ 7
start ..task@ 4
start ..task@ 3
finish task@ 1
start ..task@ 5
finish task@ 4
finish task@ 3
finish task@ 5

ThreadPoolExecutor.CallerRunsPolicy

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 8
start ..task@ 7
finish task@ 2
finish task@ 1
start ..task@ 3
start ..task@ 4
finish task@ 6
start ..task@ 5
finish task@ 7
finish task@ 8
put task@ 9
put task@ 10
start ..task@ 9
finish task@ 4
finish task@ 3
start ..task@ 10
finish task@ 9
finish task@ 5
finish task@ 10

ThreadPoolExecutor.DiscardPolicy

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
put task@ 9
start ..task@ 7
put task@ 10
finish task@ 2
finish task@ 1
start ..task@ 3
start ..task@ 4
finish task@ 7
finish task@ 6
start ..task@ 5
finish task@ 3
finish task@ 4
finish task@ 5

ThreadPoolExecutor.DiscardOldestPolicy

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果：

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 7
put task@ 9
put task@ 10
finish task@ 6
finish task@ 7
start ..task@ 8
finish task@ 1
start ..task@ 9
finish task@ 2
start ..task@ 10
finish task@ 8
finish task@ 9
finish task@ 10

三、Java并发包下如何创建线程
我们的web项目都是部署在服务器上，浏览器端的每一个request就是一个线程，那么服务器需要并发的处理多个请求，就需要线程池技术，下面来看一下Java并发包下如何创建线程池。

1.  创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。

// 创建可以容纳3个线程的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);

2. 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

// 线程池的大小会根据执行的任务数动态分配 
ExecutorService threadPool = Executors.newCachedThreadPool();

3. 创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

// 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务
ExecutorService threadPool = Executors.newSingleThreadExecutor();

4. 创建一个可安排在给定延迟后运行命令或者定期地执行的线程池。

//效果类似于Timer定时器 
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);

每种线程池都有不同的使用场景，下面看一下这四种线程池使用起来有什么不同。
1. FixedThreadPool

import java.util.concurrent.ExecutorService; 
 import java.util.concurrent.Executors; 
 public class ThreadPoolTest { 
     public static void main(String[] args) { 
         ExecutorService threadPool = Executors.newFixedThreadPool(3); 
         for(int i = 1; i < 5; i++) { 
             final int taskID = i; 
             threadPool.execute(new Runnable() { 
                 public void run() { 
                     for(int i = 1; i < 5; i++) { 
                         try { 
                             Thread.sleep(20);// 为了测试出效果，让每次任务执行都需要一定时间 
                         } catch (InterruptedException e) { 
                             e.printStackTrace(); 
                         } 
                         System.out.println("第" + taskID + "次任务的第" + i + "次执行"); 
                     } 
                 } 
             }); 
         } 
         threadPool.shutdown();// 任务执行完毕，关闭线程池 
     } 
 } 

输出结果：

第1次任务的第1次执行 
 第2次任务的第1次执行 
 第3次任务的第1次执行 
 第2次任务的第2次执行 
 第3次任务的第2次执行 
 第1次任务的第2次执行 
 第3次任务的第3次执行 
 第1次任务的第3次执行 
 第2次任务的第3次执行 
 第3次任务的第4次执行 
 第2次任务的第4次执行 
 第1次任务的第4次执行 
 第4次任务的第1次执行 
 第4次任务的第2次执行 
 第4次任务的第3次执行 
 第4次任务的第4次执行 

上段代码中，创建了一个固定大小的线程池，容量为3，然后循环执行了4个任务，由输出结果可以看到，前3个任务首先执行完，然后空闲下来的线程去执行第4个任务，在FixedThreadPool中，有一个固定大小的池，如果当前需要执行的任务超过了池大小，那么多于的任务等待状态，直到有空闲下来的线程执行任务，而当执行的任务小于池大小，空闲的线程也不会去销毁。

2. CachedThreadPool

上段代码其它地方不变，将newFixedThreadPool方法换成newCachedThreadPool方法。
输出结果：

第3次任务的第1次执行 
 第4次任务的第1次执行 
 第1次任务的第1次执行 
 第2次任务的第1次执行 
 第4次任务的第2次执行 
 第3次任务的第2次执行 
 第2次任务的第2次执行 
 第1次任务的第2次执行 
 第2次任务的第3次执行 
 第3次任务的第3次执行 
 第1次任务的第3次执行 
 第4次任务的第3次执行 
 第2次任务的第4次执行 
 第4次任务的第4次执行 
 第3次任务的第4次执行 
 第1次任务的第4次执行 

可见，4个任务是交替执行的，CachedThreadPool会创建一个缓存区，将初始化的线程缓存起来，如果线程有可用的，就使用之前创建好的线程，如果没有可用的，就新创建线程，终止并且从缓存中移除已有60秒未被使用的线程。

3. SingleThreadExecutor       
上段代码其它地方不变，将newFixedThreadPool方法换成newSingleThreadExecutor方法。      
输出结果：

第1次任务的第1次执行 
 第1次任务的第2次执行 
 第1次任务的第3次执行 
 第1次任务的第4次执行 
 第2次任务的第1次执行 
 第2次任务的第2次执行 
 第2次任务的第3次执行 
 第2次任务的第4次执行 
 第3次任务的第1次执行 
 第3次任务的第2次执行 
 第3次任务的第3次执行 
 第3次任务的第4次执行 
 第4次任务的第1次执行 
 第4次任务的第2次执行 
 第4次任务的第3次执行 
 第4次任务的第4次执行 

4个任务是顺序执行的，SingleThreadExecutor得到的是一个单个的线程，这个线程会保证你的任务执行完成，如果当前线程意外终止，会创建一个新线程继续执行任务，这和我们直接创建线程不同，也和newFixedThreadPool(1)不同。
    
4.ScheduledThreadPool

import java.util.concurrent.ScheduledExecutorService; 
 import java.util.concurrent.TimeUnit; 
 public class ThreadPoolTest { 
     public static void main(String[] args) { 
         ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1); 
         // 5秒后执行任务 
         schedulePool.schedule(new Runnable() { 
             public void run() { 
                 System.out.println("爆炸"); 
             } 
         }, 5, TimeUnit.SECONDS); 
         // 5秒后执行任务，以后每2秒执行一次 
         schedulePool.scheduleAtFixedRate(new Runnable() { 
             @Override 
             public void run() { 
                 System.out.println("爆炸"); 
             } 
         }, 5, 2, TimeUnit.SECONDS); 
     } 
 } 

ScheduledThreadPool是一个固定大小的线程池，与FixedThreadPool类似，执行的任务是定时执行。