`
duanfei
  • 浏览: 717990 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

Java:定时启动线程及线程池的用法

    博客分类:
  • 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类似,执行的任务是定时执行。
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics