技术文章 > java >  java基础 > 正文

java DelayQueue方法的总结

小妮浅浅

在对DelayQueue入队和出队的学习时,我们讲了不少其中的核心方法,那么大家知道其中还有哪些方法吗?这里我们进行了核心方法的罗列,一共有7种使用方法,很多都是大家在学习中已经见过了的。本篇我们会就另外的poll和remove方式为大家带来使用的实例介绍。

1.DelayQueue方法

take()

获取并移除此队列的头部,在可从此队列获得到期延迟的元素之前一直等待(如有必要)。

put(E)

将指定元素插入此延迟队列。

offer(E)

将指定元素插入此延迟队列。

poll()

获取并移除此队列的头,如果此队列不包含具有已到期延迟时间的元素,则返回 null。

peek()

获取但不移除此队列的头部;如果此队列为空,则返回 null。

size()

返回此 collection 中的元素数。

clear()

自动移除此延迟队列的所有元素。

2.DelayQueue使用实例

poll用法

public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        E first = q.peek();
        if (first == null || first.getDelay(NANOSECONDS) > 0)
            return null;
        else
            return q.poll();
    } finally {
        lock.unlock();
    }
}

remove用法

    /**
     * Removes a single instance of the specified element from this
     * queue, if it is present, whether or not it has expired.
     */
    public boolean remove(Object o) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.remove(o);
        } finally {
            lock.unlock();
        }
    }
    
    /**
     * Removes a single instance of the specified element from this queue,
     * if it is present.  More formally, removes an element {@code e} such
     * that {@code o.equals(e)}, if this queue contains one or more such
     * elements.  Returns {@code true} if and only if this queue contained
     * the specified element (or equivalently, if this queue changed as a
     * result of the call).
     *
     * @param o element to be removed from this queue, if present
     * @return {@code true} if this queue changed as a result of the call
     */
    public boolean remove(Object o) {
        int i = indexOf(o);
        if (i == -1)
            return false;
        else {
            //找到将要移除元素的在数组
            removeAt(i);
            return true;
        }
    }
    
    private int indexOf(Object o) {
        if (o != null) {
            for (int i = 0; i < size; i++)
                if (o.equals(queue[i]))
                    return i;
        }
        return -1;
    }
    
    /**
     * Removes the ith element from queue.
     *
     * Normally this method leaves the elements at up to i-1,
     * inclusive, untouched.  Under these circumstances, it returns
     * null.  Occasionally, in order to maintain the heap invariant,
     * it must swap a later element of the list with one earlier than
     * i.  Under these circumstances, this method returns the element
     * that was previously at the end of the list and is now at some
     * position before i. This fact is used by iterator.remove so as to
     * avoid missing traversing elements.
     */
    @SuppressWarnings("unchecked")
    private E removeAt(int i) {
        // assert i >= 0 && i < size;
        modCount++;
        //modCount++,其他线程用以确保没有并其他线程修改
        int s = --size;
        //先将数组减-1
        if (s == i) // removed last element
            //i是从0开始的,size是从1开始的;s==i那么i就是最后一个叶子节点
            queue[i] = null;
        else {
            //将最后一个节点的元素取出赋值为moved
            E moved = (E) queue[s];
            //先将原树的最后一个叶子节点设为空
            queue[s] = null;
            //将最后一个节点补到i位置位置去,从那里开始用siftDown构建堆
            siftDown(i, moved);
            //siftDown了一圈后发现最后一节点到了i位置
            if (queue[i] == moved) {
                //用siftUp继续构建堆
                siftUp(i, moved);
                //如果原来的位置上的节点
                if (queue[i] != moved)
                    return moved;
            }
        }
        return null;
    }
    
    /**
     * Inserts item x at position k, maintaining heap invariant by
     * demoting x down the tree repeatedly until it is less than or
     * equal to its children or is a leaf.
     *
     * @param k the position to fill
     * @param x the item to insert
     */
    private void siftDown(int k, E x) {
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }
    
    @SuppressWarnings("unchecked")
    private void siftDownComparable(int k, E x) {
        //k为将要移除节点的索引值,x为入堆的数据
        Comparable<? super E> key = (Comparable<? super E>)x;
        int half = size >>> 1;        // loop while a non-leaf
        //size>>>1就是size/2,不知道干啥的还
        while (k < half) {
            //当half大于0,就一直执行;k<<1代表左移一位,也就是k*2,k*2+1就是这个节点的左节点,k*2+2就是这个节点的右节点
            int child = (k << 1) + 1; // assume left child is least
            Object c = queue[child];
            int right = child + 1;
            //right这个是右节点的索引,c是左节点的值
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                //right<size的意思是右节点还没有越界,让左节点和右节点比较一下,如果左节点大于了右节点,就让
                c = queue[child = right];
            if (key.compareTo((E) c) <= 0)
                //x比c小,就跳出循环;已经局部小顶堆了本轮堆化完毕
                break;
            //将k位置让x的子节点放进去,子节点上位了
            queue[k] = c;
            //k变为刚刚上位那个节点的索引
            k = child;
        }
        //key找到自己的位置了
        queue[k] = key;
}

以上就是java中DelayQueue方法的总结,每种不同的方法都有其独特的使用而存在,大家在使用DelayQueue的时候,可以根据实际需求进行挑选。一些常见方法我们已经介绍过了,这里就不再叙述。

免费视频教程
本文原创发布python学习网,转载请注明出处,感谢您的尊重!
相关文章
 java中DelayQueue是什么
 java DelayQueue的原理
 DelayQueue解决java中延时提醒
 java中使用DelayQueue进行查询
 java中DelayQueue入队方法
 DelayQueue在java的出队
 java DelayQueue处理订单超时
相关视频章节
 网络爬虫
 云端部署Web应用程序视频
 Web应用框架Flask和文件模板
 Web应用程序开发概述
 继承和多态
作者信息

小妮浅浅

认证0级讲师

最近文章
java编译命令是什么518
java的jdk是什么407
java Wrapper类的使用806
推荐视频
视频教程分类