java 队列

时间  2019-12-07
标签 java 队列 栏目 Java 繁體版
原文   原文链接

队列简述

Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构
Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接 口。
在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为表明的高性能队列非阻塞，一个是以BlockingQueue接口为表明的阻塞队列，不管哪一种都继承自Queuehtml

阻塞队列与非阻塞队列

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操做将会被阻塞，或者当队列是满时，往队列里添加元素的操做会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其余的线程往空的队列插入新的元素。一样，试图往已满的阻塞队列中添加新元素的线程一样也会被阻塞，直到其余的线程使队列从新变得空闲起来，如从队列中移除一个或者多个元素，或者彻底清空队列java

clipboard.png
（图片来自网络https://www.cnblogs.com/lemon...）程序员

非阻塞队列

没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口数组

内置的不阻塞队列： PriorityQueue 和 ConcurrentLinkedQueue安全

PriorityQueue 和 ConcurrentLinkedQueue 类在 Collection Framework 中加入两个具体集合实现。 网络

PriorityQueue 类实质上维护了一个有序列表。加入到 Queue 中的元素根据它们的自然排序（经过其 java.util.Comparable 实现）或者根据传递给构造函数的 java.util.Comparator 实现来定位。数据结构

ConcurrentLinkedQueue 是基于连接节点的、线程安全的队列。并发访问不须要同步。由于它在队列的尾部添加元素并从头部删除它们，因此只要不须要知道队列的大小，ConcurrentLinkedQueue 对公共集合的共享访问就能够工做得很好。收集关于队列大小的信息会很慢，须要遍历队列。多线程

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列，经过无锁的方式，实现
了高并发状态下的高性能，一般ConcurrentLinkedQueue性能好于BlockingQueue.它
是一个基于连接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最早
加入的，尾是最近加入的，该队列不容许null元素。并发

ConcurrentLinkedQueue重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。app

ConcurrentLinkedQueue例子

@RequestMapping("test-clq")
    public void testConcurrentLinkedQueue() {
        ConcurrentLinkedDeque<String> q = new ConcurrentLinkedDeque<>();
        q.offer("Java");
        q.offer("C#");
        q.offer("Javascript");
        q.offer("Python");
        // 从头获取元素,删除该元素
        System.out.println(q.poll());
        // 从头获取元素,不刪除该元素
        System.out.println(q.peek());
        // 获取总长度
        System.out.println(q.size());
        // 遍历
        for (String s : q) {
            System.out.println(s);
        }
    }

结果：
Java
C#
3
C#
Javascript
Python

BlockingQueue

阻塞队列，顾名思义，首先它是一个队列，经过一个共享的队列，可使得数据由队列的一端输入，从另一端输出；
经常使用的队列主要有如下两种：（固然经过不一样的实现方式，还能够延伸出不少不一样类型的队列，DelayQueue就是其中的一种）

  • 先进先出（FIFO）：先插入的队列的元素也最早出队列，相似于排队的功能。从某种程度上来讲这种队列也体现了一种公平性。
  • 后进先出（LIFO）：后插入队列的元素最早出队列，这种队列优先处理最近发生的事件。

多线程环境中，经过队列能够很容易实现数据共享，好比经典的“生产者”和“消费者”模型中，经过队列能够很便利地实现二者之间的数据共享。假设咱们有若干生产者线程，另外又有若干个消费者线程。若是生产者线程须要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就能够很方便地解决他们之间的数据共享问题。但若是生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的状况呢？理想状况下，若是生产者产出数据的速度大于消费者消费的速度，而且当生产出来的数据累积到必定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布之前，在多线程环境下，咱们每一个程序员都必须去本身控制这些细节，尤为还要兼顾效率和线程安全，而这会给咱们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给咱们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些状况下会挂起线程（即阻塞），一旦条件知足，被挂起的线程又会自动被唤醒）

阻塞队列（BlockingQueue）是一个支持两个附加操做的队列。这两个附加的操做是：
在队列为空时，获取元素的线程会等待队列变为非空。
当队列满时，存储元素的线程会等待队列可用。
阻塞队列经常使用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
BlockingQueue即阻塞队列，从阻塞这个词能够看出，在某些状况下对阻塞队列的访问可能会形成阻塞。被阻塞的状况主要有以下两种：

  1. 当队列满了的时候进行入队列操做
  2. 当队列空了的时候进行出队列操做

所以，当一个线程试图对一个已经满了的队列进行入队列操做时，它将会被阻塞，除非有另外一个线程作了出队列操做；一样，当一个线程试图对一个空队列进行出队列操做时，它将会被阻塞，除非有另外一个线程进行了入队列操做。
在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。经过这些高效而且线程安全的队列类，为咱们快速搭建高质量的多线程程序带来极大的便利。

下表显示了jdk1.5中的阻塞队列的操做：

　　add 增长一个元索 若是队列已满，则抛出一个IIIegaISlabEepeplian异常
　　remove 移除并返回队列头部的元素 若是队列为空，则抛出一个NoSuchElementException异常
　　element 返回队列头部的元素 若是队列为空，则抛出一个NoSuchElementException异常
　　offer 添加一个元素并返回true 若是队列已满，则返回false
　　poll 移除并返问队列头部的元素 若是队列为空，则返回null
　　peek 返回队列头部的元素 若是队列为空，则返回null
　　put 添加一个元素 若是队列满，则阻塞
　　take 移除并返回队列头部的元素 若是队列为空，则阻塞

阻塞队列操做：
aad、remove和element操做在你试图为一个已满的队列增长元素或从空队列取得元素时 抛出异常
offer、poll、peek方法。这些方法在没法完成任务时，只是给出一个出错提示而不会抛出异常
阻塞操做put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。

ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，咱们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。
ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部

LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的，若是咱们初始化时指定一个大小，它就是有边界的，若是不指定，它就是无边界的。说是无边界，实际上是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。
和ArrayBlockingQueue同样，LinkedBlockingQueue 也是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

PriorityBlockingQueue

PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue同样。须要注意，PriorityBlockingQueue中容许插入null对象。
全部插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就是按照咱们对这个接口的实现来定义的。
另外，咱们能够从PriorityBlockingQueue得到一个迭代器Iterator，但这个迭代器并不保证按照优先级顺序进行迭代。

SynchronousQueue

SynchronousQueue队列内部仅容许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另外一个线程消费

DelayQueue

（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。若是延迟都尚未期满，则队列没有头部，而且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不容许使用 null 元素。

使用BlockingQueue模拟生产者与消费者

  • 生产者
public class ProducerThread implements Runnable {
    private BlockingQueue<String> queue;
    private AtomicInteger count = new AtomicInteger();
    private volatile boolean FLAG = true;

    public ProducerThread(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "生产者开始启动....");
        while (FLAG) {
            String data = count.incrementAndGet() + "";
            try {
                boolean offer = queue.offer(data, 2, TimeUnit.SECONDS);
                if (offer) {
                    System.out.println(Thread.currentThread().getName() + ",生产队列" + data + "成功..");
                } else {
                    System.out.println(Thread.currentThread().getName() + ",生产队列" + data + "失败..");
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + ",生产者线程中止...");
    }

    public void stop() {
        this.FLAG = false;
    }

}
  • 消费者
public class ConsumerThread implements Runnable {
    private volatile boolean FLAG = true;
    private BlockingQueue<String> blockingQueue;

    public ConsumerThread(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "消费者开始启动....");
        while (FLAG) {
            try {
                String data = blockingQueue.poll(2, TimeUnit.SECONDS);
                if (data == null || data == "") {
                    FLAG = false;
                    System.out.println("消费者超过2秒时间未获取到消息.");
                    return;
                }
                System.out.println("消费者获取到队列信息成功,data:" + data);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}
  • 请求
@RequestMapping("test-blockingQueue")
    public void testBlockingQueue() {
        LinkedBlockingDeque<String> blockingDeque = new LinkedBlockingDeque<>(1);
        ProducerThread producerThread = new ProducerThread(blockingDeque);
        ConsumerThread consumerThread = new ConsumerThread(blockingDeque);
        Thread t1 = new Thread(producerThread, "生产者");
        Thread t2 = new Thread(consumerThread, "消费者");
        t1.start();
        t2.start();

        // 10秒后中止线程
        try {
            Thread.sleep(10 * 1000);
            producerThread.stop();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
  • 结果

消费者消费者开始启动....生产者生产者开始启动....生产者,生产队列1成功..消费者获取到队列信息成功,data:1生产者,生产队列2成功..消费者获取到队列信息成功,data:2生产者,生产队列3成功..消费者获取到队列信息成功,data:3生产者,生产队列4成功..消费者获取到队列信息成功,data:4生产者,生产队列5成功..消费者获取到队列信息成功,data:5生产者,生产队列6成功..消费者获取到队列信息成功,data:6生产者,生产队列7成功..消费者获取到队列信息成功,data:7生产者,生产队列8成功..消费者获取到队列信息成功,data:8生产者,生产队列9成功..消费者获取到队列信息成功,data:9生产者,生产队列10成功..消费者获取到队列信息成功,data:10生产者,生产者线程中止...消费者超过2秒时间未获取到消息.

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程