并发队列之DelayQueue

2020-02-11 16:02:05来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

并发队列之DelayQueue

  已经说了四个并发队列了,DelayQueue这是最后一个,这是一个无界阻塞延迟队列,底层基于前面说过的PriorityBlockingQueue实现的 ,队列中每个元素都有过期时间,当从队列获取元素时,只有过期元素才会出队列,而队列头部的元素是过期最快的元素;

 

一.简单使用

  可以看到我们可以自己设置超时时间和优先级队列中的比较规则,这样我们在队列中取的时候,按照最快超时的先出队;

package com.example.demo.study;

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

import lombok.Data;

public class Study0210 {

    @Data
    static class MyDelayed implements Delayed {
        private long delayTime;//该任务需要再队列中的延迟的时候
        private long expire;//这个时间表示当前时间和延迟时间相加,这里就叫做到期时间
        private String taskName;//任务的名称

        public MyDelayed(long delayTime, String taskName) {
            this.delayTime = delayTime;
            this.taskName = taskName;
            this.expire = System.currentTimeMillis()+delayTime;
        }
        
        //指定优先级队列里面的比较规则,就跟上篇博客中说的优先级队列中说的比较器一样
        @Override
        public int compareTo(Delayed o) {
            return (int)(this.getDelay(TimeUnit.MILLISECONDS)-o.getDelay(TimeUnit.MILLISECONDS));
        }

        //这个方法表示该任务在队列中还有多少剩余时间,也就是expire-当前时间
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(this.expire-System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建延迟队列
        DelayQueue<MyDelayed> queue = new DelayQueue<MyDelayed>();
        
        //创建任务丢到队列中
        Random random = new Random();
        for (int i = 1; i < 11; i++) {
            MyDelayed myDelayed = new MyDelayed(random.nextInt(500),"task"+i);
            queue.add(myDelayed);
        }
        
        //获取队列中的任务,这里只会跟超时时间最小的有关,和入队顺序无关
        MyDelayed myDelayed = queue.take();
        while(myDelayed!=null) {
            System.out.println(myDelayed.toString());
            myDelayed = queue.take();
        }
    }
}

 

 

 

二.基本组成 

//由此可是这个队列中存放的任务必须是Delayed类型的
public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E> {
    //独占锁
    private final transient ReentrantLock lock = new ReentrantLock();
    //优先级队列
    private final PriorityQueue<E> q = new PriorityQueue<E>();
    //leader线程,实际上每次进行入队和出队操作的只能是leader线程,其余的都叫做fallower线程,这里会用到一个leader-follower模式
    private Thread leader = null;
    //条件变量
    private final Condition available = lock.newCondition();

    //省略很多代码
}

 

  

  具体的继承关系可以看看下面这个图,实际操作的都是内部的PriorityQueue;

 

 

三.offer方法

  上面代码中我们虽然说调用的是add方法,其实就是调用的是offer方法;

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        //往优先级队列中添加一个元素
        q.offer(e);
        //注意,peek方法只是获取优先级队列中第一个元素,并不会删除
        //如果优先级队列中取的元素就是和当前添加的元素一样,说明当前元素就是达到过期要求的,于是设置leader线程为null
        //然后通知条件队列中的线程优先级队列中已经有元素了,可以过来取了
        if (q.peek() == e) {
            leader = null;
            available.signal();
        }
        return true;
    } finally {
        //释放锁
        lock.unlock();
    }
}

 

 

四.take方法

  获取并移除队列中达到超时时间要求的元素,如果队列中没有元素,就把当前线程丢到条件队列中阻塞;

  从下面的代码逻辑中我们可以知道:线程分为两种,一种是leader线程,一种是follower线程,其中leader线程只会阻塞一定的时间,follower线程会在条件队列阻塞无限长的时间;当leader线程执行完take操作之后,就会重置leader线程为null,然后从条件队列中拿一个出来设置为leader线程

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    //获取锁,可中断
    lock.lockInterruptibly();
    try {
        for (;;) {
            //这里先是尝试从优先级队列中获取一下节点,获取不到的话,说明当前优先级队列为空,就阻塞当前线程
            E first = q.peek();
            if (first == null)
                available.await();
            else {
                //如果优先级队列中有元素,那么肯定能走到这里来,然后取到该元素的超时时间,如果小于0,说明已经达到要求了,可以获取并删除队列中的元素
                long delay = first.getDelay(NANOSECONDS);
                if (delay <= 0)
                    return q.poll();
                first = null; // don't retain ref while waiting
                //如果leader队列不为空,说明有其他线程正在执行take,于是就把当前线程放到条件队列中
                if (leader != null)
                    available.await();
                //到这里,说明优先级队列中没有元素到超时时间,而且此时没有其他线程调用take方法,于是就把leader线程设置为当前线程,
                //然后当前leader线程就会等待一定的时间,等优先级队列中最快超时的元素;
                //在等待的时候,leader线程会释放锁,这时其他线程B可以调用offer方法添加元素,线程C也可以调用take方法,然后线程C就会在
                //上面这里阻塞无限长的时间,直到被唤醒
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay);
                    } finally {
                        //当前线程阻塞一定时间之后,不管成功了没有,都会把leader线程重置为null,然后重新循环
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    //这里的意思就是当前线程移除元素成功之后,唤醒条件队列中的线程去继续从队列中获取元素
    } finally {
        if (leader == null && q.peek() != null)
            available.signal();
        //释放锁
        lock.unlock();
    }
}

 

 

五.poll操作

  获取并移除队头过期元素,如果队列为空,或者对头元素没有过超时时间就返回null

public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //尝试获取队头元素,如果队头元素为空或者该延迟过期时间还没到,就返回null
        E first = q.peek();
        if (first == null || first.getDelay(NANOSECONDS) > 0)
            return null;
        else
        //否则就获取并移除队头元素
            return q.poll();
    } finally {
        lock.unlock();
    }
}

 

 

六.总结

  这个队列其实很容易,主要的是有一个延迟时间,我们从优先级队列中获取的根节点首先会判断有没有过超时时间,有的话就移除并返回就好了,没有的话,就看看还剩下多少时间才会超时(由于是优先级队列,所以根节点一般就是最快超时时间的,当然,也可以修改优先级队列的比较规则),于是当前线程就会等这个节点超时,此时leader等于当前线程,在等待的过程中,会释放锁,所以其他线程可以往队列中添加元素,也可以获取元素(但是由于此时leader!=null,这些线程会阻塞无限长时间直到被唤醒);

  在leader线程超时时间到了之后自动唤醒,再进行一次循环,就会获取并移除根节点了,最后再重置leader节点为null,顺便唤醒条件队列中的节点;

 


原文链接:https://www.cnblogs.com/wyq1995/p/12293345.html
如有疑问请与原作者联系

标签:sysClassIEPOSTname判断

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Spring Boot 2.x基础教程:使用国产数据库连接池Druid

下一篇:【笔记3-用户模块】从0开始 独立完成企业级Java电商网站开发(服