优先级阻塞队列的应用

一 点睛

1 BlockingQueue 接口中各方法解读

public interface BlockingQueue<E> extends Queue<E> {
    /**
        向 BlockingQueue 中增加元素。如果 BlockingQueue 中有剩余空间，则返回 true，否则抛出异常，通常与 poll() 结合使用
     */
    boolean add(E e);


    /**
        向 BlockingQueue 中增加元素。如果 BlockingQueue 中有剩余空间，则返回 true，否则返回 false，通常与 poll() 结合使用
     */
    boolean offer(E e);


    /**
    向 BlockingQueue 中增加元素。如果 BlockingQueue 中有剩余空间，则直接入队，否则当前线程会一直等待，直到 BlockingQueue 中有剩余空间，通常与 take() 结合使用。
     */
    void put(E e) throws InterruptedException;


    /**
        带超时功能的 offer 版本
     */
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;


    /**
        取出排在 BlockingQueue 队首的元素，若队伍为空，则当前线程一直等待。
     */
    E take() throws InterruptedException;


    /**
        取出排在 BlockingQueue 队首的元素，若队伍为空，则会持续等待一定的时间，如果等待之后队列还是为空，则返回 NULL
     */
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;


    /**
        返回队列的剩余容量。注意：队列可能被其他线程进行了增减操作，因此线程 A 看到的数字不具备实战性。
     */
    int remainingCapacity();


    /**
        删除队列中的 o 元素
     */
    boolean remove(Object o);


    /**
        判断队列中是否包含 o 元素
     */
    public boolean contains(Object o);


    /**
        将队列中的元素全部转移到集合 c 中
     */
    int drainTo(Collection<? super E> c);


    /**
        将队列中的前 maxElements 个元素全部转移到集合 c 中
     */
    int drainTo(Collection<? super E> c, int maxElements);
}

2 有界队列和无界队列

BlockingQueue 的实现类可以分为有界队列和无界队列，有界队列是指队列中的元素个数是有限的，而无界队列指的是队列中元素个数可以是无穷多个。

BlockingQueue 的常见实现类如下所述。

类别	描述
ArrayBlockingQueue	由数组构成的有界阻塞队列，队列的大小由构造方法的参数指定。
LinkedBlockingQueue	由链表结构组成的有界阻塞队列。可通过构造方法的参数指定队列的大小；如果使用无参构造方法，则队列默认的大小是 Integer.MAX_VALUE。
PriorityBlockingQueue	一个支持优先级排序的无界阻塞队列，排序规则可以通过构造方法中的 Comparator对象指定。
DelayQueue	一个支持延迟存取的无界队列，如队列中的某个元素必须在一定时间后能被取出。

二 PriorityBlockingQueue  队列实战

1 实现了 Comparable 接口的 MyJob 类

package concurrent.myjob;

public class MyJob implements Comparable<MyJob> {
    private int id;

    public MyJob(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    /**
     * 功能描述：按照 id 升序排列
     *
     * @param job 工作
     * @return int
     * @author cakin
     * @date 2022/3/21
     */
    @Override
    public int compareTo(MyJob job) {
        return this.id > job.id ? 1 : (this.id < job.id ? -1 : 0);
    }

    @Override
    public String toString() {
        return String.valueOf(this.id);
    }
}

2 测试类

package concurrent.myjob;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

/**
* @className: TestPriorityBlockingQueue
* @description: 测试阻塞队列
* @date: 2022/3/21
* @author: cakin
*/
public class TestPriorityBlockingQueue {

    public static void main(String[] args) throws Exception {
        // 通过构造方法，传入了一个实现了 Comparable 接口的 MyJob 类，在 MyJob 类中通过重写 compareTo() 定义了优先级规则
        BlockingQueue<MyJob> priorityQueue = new PriorityBlockingQueue<>();
        priorityQueue.add(new MyJob(3));
        priorityQueue.add(new MyJob(2));
        priorityQueue.add(new MyJob(1));
        // 优先级的排序规则，会在第一次调用take()方法之后生效
        System.out.println("队列：" + priorityQueue); // 默认队中的顺序是 3，2，1
        System.out.println("取出队列中的一个元素：" + priorityQueue.take().getId()); // 排序后，队中的顺序是1，2，3
        System.out.println("容器：" + priorityQueue);
    }
}

三 测试

队列：[1, 3, 2]

取出队列中的一个元素：1

容器：[2, 3]