Java中Queue队列简析

目录

1. 非阻塞队列PriorityQueue
2. 非阻塞队列ConcurrentLinkedDeque
3. 阻塞队列ArrayBlockingQueue
4. 阻塞队列LinkedBlockingQueue
5. 阻塞队列PriorityQueueBlockingQueue
6. 延迟队列DelayQueue

一、PriorityQueue

        /**
         * 线程安全: 否
         * 是否阻塞: 否
         * 数据结构: 底层为数组, 会按照指定规则进行排序, 排序算法有点难度,可自行参考源码
         * 研究
         * 建议使用方法: offer增加元素, 返回是否添加成功; poll方法弹出元素, 如队列为空, 则返回null
         */
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.forEach(System.out::println);
        priorityQueue.poll();

二、ConcurrentLinkedDeque

        /**
         * 线程是否安全: 否
         * 是否阻塞: 否
         * 数据结构: 底层为双向链表结构
         * 建议使用方法: offer增加元素, 返回是否添加成功; poll方法弹出元素, 如队列为空, 则返回null
         */
        ConcurrentLinkedDeque<Integer> concurrentLinkedDeque = new ConcurrentLinkedDeque<>();
        concurrentLinkedDeque.offer(1);
        concurrentLinkedDeque.offer(2);
        concurrentLinkedDeque.forEach(System.out::println);
        concurrentLinkedDeque.poll();

三、ArrayBlockingQueue

        /**
         * 线程是否安全: 是
         * 是否阻塞: offer不阻塞, put阻塞; poll不阻塞, take阻塞
         * 数据结构: 底层为一个指定大小的数组结构
         * 建议使用方法: 根据业务需求自行决定使用哪种方法
         */
        ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<Integer>(1);
        try {
            arrayBlockingQueue.offer(1);
            arrayBlockingQueue.put(2);
            arrayBlockingQueue.poll();
            arrayBlockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        arrayBlockingQueue.forEach(System.out::println);

四、LinkedBlockingQueue

        /**
         * 线程是否安全: 是
         * 是否阻塞: offer和put方法不阻塞; poll方法不阻塞, take方法阻塞
         * 数据结构: 底层为双向链表结构
         * 建议使用方法: 根据业务场景自行选择offer, put, poll和take方法
         */
        LinkedBlockingDeque<Integer> linkedBlockingDeque = new LinkedBlockingDeque<>();
        try {
            linkedBlockingDeque.offer(1);
            linkedBlockingDeque.put(2);
            linkedBlockingDeque.poll();
            linkedBlockingDeque.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        linkedBlockingDeque.forEach(System.out::println);

五、PriorityQueueBlockingQueue

        /**
         * 线程是否安全: 否
         * 是否阻塞: offer和put方法不阻塞, poll方法不阻塞, take方法阻塞
         * 数据结构: 底层使用PriorityQueue数据结构
         * 建议使用方法: 根据业务场景选择使用offer, put, poll和take方法
         */
        PriorityBlockingQueue<Integer> priorityBlockingQueue = new PriorityBlockingQueue<>();
        try {
            priorityBlockingQueue.offer(1);
            priorityBlockingQueue.put(2);
            priorityBlockingQueue.poll();
            priorityBlockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        priorityBlockingQueue.forEach(System.out::println);

六、DelayQueue

        /**
         * 线程是否安全: 是
         * 是否阻塞: offer和put方法不阻塞; poll不阻塞, take方法阻塞
         * 数据机构: 底层复用PriorityQueue队列数据结构, 按照延时时间长短进行排序
         * 建议使用方法: 根据业务场景进行选择
         */
        DelayQueue<MyDelayQueueTask> delayQueue = new DelayQueue<>();
        try {
            delayQueue.offer(new MyDelayQueueTask());
            delayQueue.put(new MyDelayQueueTask());
            delayQueue.poll();
            delayQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        delayQueue.forEach(System.out::println);


        class MyDelayQueueTask implements Delayed {
        private long endTime = System.currentTimeMillis() + 10000;

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(endTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
        }
    }

如想详细了解各队列的详细信息，还请查看源码。