当前位置: 首页 > Thinking in Java > 正文

第21章 – 并发 – 新类库中构件 – DelayQueue

第21章 – 并发 – 新类库中构件 – DelayQueue

 

1. DelayQueue简介

 

   DelayQueue是BlockingQueue接口的一个实现类,要求放入队列中的对象都要实现Delay接口.

 

   Delayed 元素的一个无界阻塞队列,只有在延迟期满时才能从中提取元素。

 

   一般可以将一个Runnable放到这个DelayQueue中,可以实现任务的延迟执行.

 

   该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。

   如果延迟都还没有期满,则队列没有头部,并且 poll 将返回 null。

   当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时,将发生到期。

   即使无法使用 take 或 poll 移除未到期的元素,也不会将这些元素作为正常元素对待。

   例如,size 方法同时返回到期和未到期元素的计数。此队列不允许使用 null 元素。 

 

   public interface Delayed extends Comparable<Delayed>

   long getDelay(TimeUnit unit) 返回与此对象相关的剩余延迟时间,以给定的时间单位表示。

 

 

2.示例代码:

package concurrency;

		import java.util.ArrayList;
		import java.util.List;
		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;
		
		class DelayedTask implements Runnable,Delayed
		{
		  private static int counter = 0;
		  private final int id = counter++;
		  private final int delta; //延迟执行的时间长度(毫秒)
		  private final long trigger; //延迟后,执行发生的时间
		  protected static List<DelayedTask> sequence = new ArrayList<DelayedTask>();
		  
		  public DelayedTask(int delayInMilliseconds)
		  {
		    delta = delayInMilliseconds;
		    trigger = System.nanoTime() + TimeUnit.NANOSECONDS.convert(delta,TimeUnit.MILLISECONDS);
		    //将毫秒转换成纳秒
		    sequence.add(this);
		  }
		  
		  @Override
		  public void run()
		  {
		    System.out.println(this + " ");
		  }
		  
		  public String toString()
		  {
		    return String.format("[%1$-3d]",delta) + " Task " + id;
		  }
		  
		  public String summary()
		  {
		    return "(" + id + ":" + delta + ")";
		  }
		
		  //返回与此对象相关的剩余延迟时间,以给定的时间单位表示
		  @Override
		  public long getDelay(TimeUnit unit)
		  {
		    return unit.convert(trigger - System.nanoTime(),TimeUnit.NANOSECONDS);
		  }
		
		  @Override
		  public int compareTo(Delayed arg0)
		  {
		    DelayedTask that = (DelayedTask) arg0;
		    if(trigger < that.trigger) return -1;
		    if(trigger > that.trigger) return 1;
		    return 0;
		  }
		  
		  public static class EndSentinel extends DelayedTask
		  {
		    private ExecutorService exec;
		    
		    public EndSentinel(int delay,ExecutorService e)
		    {
		      super(delay);
		      exec = e;
		    }
		    
		    public void run()
		    {
		      for(DelayedTask pt:sequence)
		      {
		        System.out.println(pt.summary());
		      }
		      System.out.println("");
		      System.out.println(this + " calling shutdownNow()");
		      exec.shutdownNow();
		    }
		    
		  }
		  
		}
		
		class DelayedTaskConsumer implements Runnable
		{
		  private DelayQueue<DelayedTask> q;
		  public DelayedTaskConsumer(DelayQueue<DelayedTask> q)
		  {
		    this.q = q;
		  }
		  
		  public void run()
		  {
		    try
		    {
		      while(!Thread.interrupted())
		      {
		        //take()只在有元素延迟到期之后才返回,如果没有到期的元素,则当前线程阻塞
		        q.take().run(); 
		        //在当前线程中运行 放到DelayQueue 中的 DelayedTask
		        //仅仅是实现了Runnable接口的类的run()方法而已.
		      }
		    }
		    catch (InterruptedException e)
		    {
		      // TODO: handle exception
		    }
		    
		    System.out.println("Finished DelayTaskConsumer");
		    
		  }
		}
		
		
		public class DelayQueueDemo
		{
		  public static void main(String[] args)
		  {
		    Random rand = new Random(47);
		    
		    ExecutorService exec = Executors.newCachedThreadPool();
		    
		    DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
		    
		    for(int i=0;i<5;i++)
		    {
		      queue.put(new DelayedTask(rand.nextInt(5000)));
		    }
		    
		    //DelayQueue中加入最后一个任务,用来终结线程DelayedTaskConsumer的执行
		    queue.add(new DelayedTask.EndSentinel(5000,exec));
		    //5000表示这个终结线程延迟5000毫秒后执行,
		    //而其他DelayQueue中的任务都是延迟rand.nextInt(5000)之后执行
		    //这样可以保证 EndSentinel 是最后一个执行的.
		    exec.execute(new DelayedTaskConsumer(queue));
		    //这里有意思的是,使用exec执行一个Runnable了,这个Runnable可以获取到这个exec
		    //然后在Runnable运行是执行exec的shutdownNow()方法,用来终结字节.
		  }
		}
		/**
		 * 运行结果如下
		 * 
		[555] Task 1 
		[961] Task 4 
		[1693] Task 2 
		[1861] Task 3 
		[4258] Task 0 
		(0:4258)
		(1:555)
		(2:1693)
		(3:1861)
		(4:961)
		(5:5000)
		
		[5000] Task 5 calling shutdownNow()
		Finished DelayTaskConsumer
		
		[555] Task 1 表示线程1 在延迟500毫秒之后执行
		(0:4258) 是表示0号Runnable延迟时间4258毫秒之后执行
		由输出可知,确实是按照延迟时间来依次执行的 
		 */

 

——————————–华丽丽的分割线—————————————

 

   Delayed接口继承自public interface Comparable<T>

 

   此接口强行对实现它的每个类的对象进行整体排序。

   这种排序被称为类的自然排序,类的 compareTo 方法被称为它的自然比较方法。

 

实现此接口的对象列表(和数组)可以通过 Collections.sort(和 Arrays.sort)进行自动排序。

实现此接口的对象可以用作有序映射中的键或有序集合中的元素,无需指定比较器。

 

对于类 C 的每一个 e1 和 e2 来说,当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时,

类 C 的自然排序才叫做与 equals 一致。

 

注意,null 不是任何类的实例,即使 e.equals(null) 返回 false,

e.compareTo(null) 也将抛出 NullPointerException。

 

建议(虽然不是必需的)最好使自然排序与 equals 一致。

这是因为在使用自然排序与 equals 不一致的元素(或键)时,

没有显式比较器的有序集合(和有序映射表)行为表现“怪异”。

尤其是,这样的有序集合(或有序映射表)违背了根据 equals 方法定义的集合(或映射表)的常规协定。

 

例如,如果将两个键 a 和 b 添加到没有使用显式比较器的有序集合中,

使 (!a.equals(b) && a.compareTo(b) == 0),那么第二个 add 操作将返回 false(有序集合的大小没有增加),因为从有序集合的角度来看,a 和 b 是相等的。

 

实际上,所有实现 Comparable 的 Java 核心类都具有与 equals 一致的自然排序。

java.math.BigDecimal 是个例外,它的自然排序将值相等但精确度不同的 BigDecimal 对象(比如 4.0 和 4.00)视为相等。

 

从数学上讲,定义给定类 C 上自然排序的关系式 如下:{(x, y)|x.compareTo(y) <= 0}。

整体排序的商 是:

     {(x, y)|x.compareTo(y) == 0}。

它直接遵循 compareTo 的协定,商是 C 的等价关系,自然排序是 C 的整体排序。

当说到类的自然排序与 equals 一致 时,是指自然排序的商是由类的 equals(Object) 方法定义的等价关系。

{(x, y)|x.equals(y)}。

 

   int compareTo(T o)  比较此对象与指定对象的顺序。 

 

   比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。

 

实现类必须确保对于所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的关系。

(这意味着如果 y.compareTo(x) 抛出一个异常,则 x.compareTo(y) 也要抛出一个异常。) 

 

实现类还必须确保关系是可传递的:

(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0。 

 

最后,实现者必须确保 x.compareTo(y)==0 意味着对于所有的 z,

都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。 

强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法,但并不是 严格要求这样做。

 

一般来说,任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。

推荐如此阐述:“注意:此类具有与 equals 不一致的自然排序。” 

 

在前面的描述中,符号 sgn(expression) 指定 signum 数学函数,

该函数根据 expression 的值是负数、零还是正数,分别返回 -1、0 或 1 中的一个值。 

 

参数:

o – 要比较的对象。 

返回:

负整数、零或正整数,根据此对象是小于、等于还是大于指定对象。 

抛出: 

ClassCastException – 如果指定对象的类型不允许它与此对象进行比较。

赞 赏

   微信赞赏  支付宝赞赏


本文固定链接: https://www.jack-yin.com/coding/thinking-in-java/2120.html | 边城网事

该日志由 边城网事 于2015年03月18日发表在 Thinking in Java 分类下, 你可以发表评论,并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: 第21章 – 并发 – 新类库中构件 – DelayQueue | 边城网事
关键字: ,

第21章 – 并发 – 新类库中构件 – DelayQueue 暂无评论

发表评论

快捷键:Ctrl+Enter