最近工作中有接触到DelayQueue,网上搜索资料的时候发现一篇文章谈到DelayQueue的坑。点击打开链接

文中已经总结了遇到坑的地方,还有解决方案。不过我第一眼看一下没弄明白为什么,所以翻了翻源码深究了一下,下面把这个坑的原因以及原理分析一下。


首先是DelayQueue的take()方法:

    public E take() throws InterruptedException { 
        final ReentrantLock lock = this.lock; 
        lock.lockInterruptibly(); 
        try { 
            for (;;) { 
                E first = q.peek(); 
                if (first == null) 
                    available.await(); 
                else { 
                    long delay = first.getDelay(NANOSECONDS);    // 1 
                    if (delay <= 0) 
                        return q.poll(); 
                    first = null; // don't retain ref while waiting 
                    if (leader != null) 
                        available.await(); 
                    else { 
                        Thread thisThread = Thread.currentThread(); 
                        leader = thisThread; 
                        try { 
                            available.awaitNanos(delay);    // 2 
                        } finally { 
                            if (leader == thisThread) 
                                leader = null; 
                        } 
                    } 
                } 
            } 
        } finally { 
            if (leader == null && q.peek() != null) 
                available.signal(); 
            lock.unlock(); 
        } 
    }

首先看到注释2,这是一个带时间的await方法,时间单位是纳秒,传入的参数delay是从注释1通过调用first对象的getDelay方法获取的。first对象是E类型的,E是一个实现了Delayed接口的泛型。

这里看看接口Delayed的源码:

public interface Delayed extends Comparable<Delayed> { 
 
    /** 
     * Returns the remaining delay associated with this object, in the 
     * given time unit. 
     * 
     * @param unit the time unit 
     * @return the remaining delay; zero or negative values indicate 
     * that the delay has already elapsed 
     */ 
    long getDelay(TimeUnit unit); 
}

就只有一个getDelay(TimeUnit)方法,它返回的指定的TimeUnit的时间长度。显然,具体的实现类要实现该方法才行。


那么来看一下具体的getDelay(TimeUnit)方法的实现吧,我看了几篇文章,基本上大同小异,都是如下这般实现的:

    public long getDelay(TimeUnit unit) { 
        return unit.convert(this.expire - System.currentTimeMillis() , TimeUnit.MILLISECONDS); 
    }

原博主很贴心的提醒了,这个地方convert方法的第二个参数,应该要使用TimeUnit.MILLISECONDS而不是TimeUnit.NANOSECONDS(虽然不管使用什么时间单位都不会导致程序出现错误的结果,但是用错了时间单位的话,CPU可就遭殃了)。那么为什么会一定要强调要使用MILLISECONDS这个单位呢?

继续看看convert方法的源码吧,在TimeUnit枚举类中,定义了若干时间单位,他们有各自的convert方法的实现,先来看看TimeUnit.NANOSECONDS的:

    NANOSECONDS { 
        public long toNanos(long d)   { return d; } 
        public long toMicros(long d)  { return d/(C1/C0); } 
        public long toMillis(long d)  { return d/(C2/C0); } 
        public long toSeconds(long d) { return d/(C3/C0); } 
        public long toMinutes(long d) { return d/(C4/C0); } 
        public long toHours(long d)   { return d/(C5/C0); } 
        public long toDays(long d)    { return d/(C6/C0); } 
        public long convert(long d, TimeUnit u) { return u.toNanos(d); } 
        int excessNanos(long d, long m) { return (int)(d - (m*C2)); } 
    },

可以看到,convert方法又直接调用了TimeUnit.toNanos方法,直接就把第一个参数d当做一个纳秒的时间长度给返回了。

同理看看TimeUnit.MILLISECONDS定义的方法:

    MILLISECONDS { 
        public long toNanos(long d)   { return x(d, C2/C0, MAX/(C2/C0)); }    //static final long C0 = 1L; static final long C1 = C0 * 1000L;static final long C2 = C1 * 1000L; 
        public long toMicros(long d)  { return x(d, C2/C1, MAX/(C2/C1)); } 
        public long toMillis(long d)  { return d; } 
        public long toSeconds(long d) { return d/(C3/C2); } 
        public long toMinutes(long d) { return d/(C4/C2); } 
        public long toHours(long d)   { return d/(C5/C2); } 
        public long toDays(long d)    { return d/(C6/C2); } 
        public long convert(long d, TimeUnit u) { return u.toMillis(d); } 
        int excessNanos(long d, long m) { return 0; } 
    },

回到我们的实际使用场景,take方法中long delay = first.getDelay(NANOSECONDS);  ->  NANOSECONDS.convert(long d, TimeUnit u)  ->  u.toNanos(d)。如果我们在getDelay方法实现中,convert方法第二个参数传入的是NANOSECONDS,那么就直接返回d;如果convert方法第二个参数传入的是MILLISECONDS,那么返回就是MILLISECONDS.toNanos(d),得到的结果就是1000*1000*d。

可以发现,convert方法的第二个参数TimeUnit,实际上是跟着第一个参数d的时间单位走的。如果实现时候直接使用time - System.currentTimeMillis()作为第一个参数,实际上它的时间单位确实应该是MILLISECONDS,那么如果第二个参数传错了为NANOSECONDS,那就导致take方法中的awaitNanos方法等待时间缩短了1000*1000倍,这样带来的cpu空转压力是巨大的。


分析了这么多,其实看看jdk中TimeUnit类对convert方法的注释,很容易就理解了:

    /** 
     * Converts the given time duration in the given unit to this unit. 
     * Conversions from finer to coarser granularities truncate, so 
     * lose precision. For example, converting [email protected] 999} milliseconds 
     * to seconds results in [email protected] 0}. Conversions from coarser to 
     * finer granularities with arguments that would numerically 
     * overflow saturate to [email protected] Long.MIN_VALUE} if negative or 
     * [email protected] Long.MAX_VALUE} if positive. 
     * 
     * <p>For example, to convert 10 minutes to milliseconds, use: 
     * [email protected] TimeUnit.MILLISECONDS.convert(10L, TimeUnit.MINUTES)} 
     * 
     * @param sourceDuration the time duration in the given [email protected] sourceUnit} 
     * @param sourceUnit the unit of the [email protected] sourceDuration} argument 
     * @return the converted duration in this unit, 
     * or [email protected] Long.MIN_VALUE} if conversion would negatively 
     * overflow, or [email protected] Long.MAX_VALUE} if it would positively overflow. 
     */ 
    public long convert(long sourceDuration, TimeUnit sourceUnit) { 
        throw new AbstractMethodError(); 
    }

这里很明确的指出了,convert方法的第二个参数sourceUnit(@param sourceUnit the unit of the [email protected] sourceDuration} argument)应该是第一个参数sourceDuration的时间单位。会产生原链接中提到的那样的错误使用,应该就是理解错了这个convert方法参数的含义,以为第二个参数的时间单位是要转换到的时间单位。

不过这个陷阱确实有点绕,在getDelay(TimeUnit unit)方法里面,调用unit.convert(long sourceDuration, TimeUnit sourceUnit)方法,一下出来了两个TimeUnit变量,不仔细一点的话真是容易被坑啊。当然,要是自身的getDelay方法实现不用unit.convert方法或许就避免了该问题了。

发布评论
IT源码网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

从输入网址到显示网页的全过程分析讲解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。