java中隊列的介紹和使用

這期內容當中小編將會給大家帶來有關java中隊列的介紹和使用，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

隊列是一種特殊的線性表，遵循的原則就是“先入先出”。在我們日常使用中，經常會用來并發操作數據。在并發編程中，有時候需要使用線程安全的隊列。如果要實現一個線程安全的隊列通常有兩種方式：一種是使用阻塞隊列，另一種是使用線程同步鎖。

什么是阻塞隊列？

假設有一個面包房，里面有一個客人吃面包，一個師傅烤面包。籃子里面最多放2個面包，師傅考完了面包放到籃子里，而客人吃面包則從籃子里面往外拿，為了保證客人吃面包的時候籃子里有面包或者師傅烤面包的時候籃子不會溢出，這時候就需要引用出來阻塞隊列的概念，就是我們常說的生產者消費者的模式。

阻塞隊列是一個支持兩個附加操作的隊列。這兩個附加的操作支持阻塞的插入和移除方法。

（1）支持阻塞的插入方法：意思是當隊列滿時，隊列會阻塞插入元素的線程，直到隊列不滿。

（2）支持阻塞的移除方法：意思是在隊列為空時，獲取元素的線程會等待隊列變為非空。阻塞隊列常用于生產者和消費者的場景，生產者是向隊列里添加元素的線程，消費者是從隊列里取元素的線程。阻塞隊列就是生產者用來存放元素、消費者用來獲取元素的容器。

系統內不阻塞隊列：PriorityQueue 和 ConcurrentLinkedQueue

我們來看一下不阻塞隊列的關系（以PriorityQueue 為例）：

PriorityQueue 類繼承自AbstractQueue，實現了Serializable接口。實質上維護了一個有序列表，PriorityQueue位于Java util包中，觀其名字前半部分的單詞Priority是優先的意思，實際上這個隊列就是具有“優先級”。加入到 Queue 中的元素根據它們的天然排序（通過其 java.util.Comparable 實現）或者根據傳遞給構造函數的 java.util.Comparator 實現來定位。

ConcurrentLinkedQueue 是基于鏈接節點的、線程安全的隊列。并發訪問不需要同步。因為它在隊列的尾部添加元素并從頭部刪除它們，所以不需要知道隊列的大小， ConcurrentLinkedQueue 對公共集合的共享訪問就可以工作得很好。收集關于隊列大小的信息會很慢，需要遍歷隊列；ConcurrentLinkedQueue是一個基于鏈接節點的無界線程安全隊列，它采用先進先出的規則對節點進行排序，當我們添加一個元素的時候，它會添加到隊列的尾部；當我們獲取一個元素時，它會返回隊列頭部的元素。

實現阻塞接口的隊列：

java.util.concurrent 中加入了 BlockingQueue 接口和五個阻塞隊列類。它實質上就是一種帶有一點扭曲的 FIFO 數據結構。不是立即從隊列中添加或者刪除元素，線程執行操作阻塞，直到有空間或者元素可用。

五個隊列所提供的各有不同：

·ArrayBlockingQueue ：一個由數組支持的有界隊列。

·LinkedBlockingQueue ：一個由鏈接節點支持的可選有界隊列。

·PriorityBlockingQueue ：一個由優先級堆支持的無界優先級隊列。

·DelayQueue ：一個由優先級堆支持的、基于時間的調度隊列。

·SynchronousQueue ：一個利用 BlockingQueue 接口的簡單聚集（rendezvous）機制。

我們看一下ArrayBlockingQueue 和LinkedBlockingQueue 的繼承關系：

通過查看兩個類的繼承關系，我們可以知道，他們也是繼承自AbstractQueue，實現了Serializable接口；不同的是他們同時實現了BlockingQueue接口。

簡單介紹下其中的幾個：

LinkedBlockingQueueLinkedBlockingQueue默認大小是Integer.MAX_VALUE，可以理解為一個緩存的有界等待隊列，可以選擇指定其最大容量，它是基于鏈表的隊列，此隊列按 FIFO（先進先出）排序元素。當生產者往隊列中放入一個數據時，緩存在隊列內部，當隊列緩沖區達到最大值緩存容量時（LinkedBlockingQueue可以通過構造函數指定該值），阻塞生產者隊列，直到消費者從隊列中消費掉一份數據，生產者線程會被喚醒，反之對于消費者同理。

ArrayBlockingQueue在構造時需要指定容量， 并可以選擇是否需要公平性，如果公平參數被設置true，等待時間最長的線程會優先得到處理（其實就是通過將ReentrantLock設置為true來 達到這種公平性的：即等待時間最長的線程會先操作）。通常，公平性會使你在性能上付出代價，只有在的確非常需要的時候再使用它。它是基于數組的阻塞循環隊列，此隊列按FIFO（先進先出）原則對元素進行排序。

PriorityBlockingQueue是一個帶優先級的 隊列，而不是先進先出隊列。元素按優先級順序被移除，該隊列也沒有上限（看了一下源碼，PriorityBlockingQueue是對 PriorityQueue的再次包裝，是基于堆數據結構的，而PriorityQueue是沒有容量限制的，與ArrayList一樣，所以在優先阻塞 隊列上put時是不會受阻的。雖然此隊列邏輯上是無界的，但是由于資源被耗盡，所以試圖執行添加操作可能會導致 OutOfMemoryError），但是如果隊列為空，那么取元素的操作take就會阻塞，所以它的檢索操作take是受阻的。另外，往入該隊列中的元 素要具有比較能力。

關于ConcurrentLinkedQueue和LinkedBlockingQueue：

也可以理解為阻塞隊列和非阻塞隊列的區別：

1.LinkedBlockingQueue是使用鎖機制，ConcurrentLinkedQueue是使用CAS算法，雖然LinkedBlockingQueue的底層獲取鎖也是使用的CAS算法。

2.關于取元素，ConcurrentLinkedQueue不支持阻塞去取元素，LinkedBlockingQueue支持阻塞的take()方法。

3.關于插入元素的性能，但在實際的使用過程中，尤其在多cpu的服務器上，有鎖和無鎖的差距便體現出來了，ConcurrentLinkedQueue會比LinkedBlockingQueue快很多。

生產者消費者代碼：

在網上看到一個生產者消費者的小例子，對于理解阻塞隊列非常有幫助，代碼如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class BlockingQueueTest {
    public static class Basket {
        BlockingQueue<String> basket = new ArrayBlockingQueue<>(3);
 
        private void produce() throws InterruptedException {
            basket.put("蘋果");
        }
 
        private void consume() throws InterruptedException {
            basket.take();
        }
 
        private int getAppleNumber() {
            return basket.size();
        }
    }
 
    private static void testBasket() {
        final Basket basket = new Basket();
        class Producer implements Runnable {
            public void run() {
                try {
                    while (true) {
                        System.out.println("生產者開始生產蘋果###");
                        basket.produce();
                        System.out.println("生產者生產蘋果完畢###");
                        System.out.println("籃子中的蘋果數量：" + basket.getAppleNumber() + "個");
                        Thread.sleep(300);
                    }
                } catch (InterruptedException e) {}
            }
        }
 
        class Consumer implements Runnable {
            public void run() {
                try {
                    while (true) {
                        System.out.println("消費者開始消費蘋果***");
                        basket.consume();
                        System.out.println("消費者消費蘋果完畢***");
                        System.out.println("籃子中的蘋果數量：" + basket.getAppleNumber() + "個");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {}
            }
        }
        ExecutorService service = Executors.newCachedThreadPool();
        Producer producer = new Producer();
        Consumer consumer = new Consumer();
        service.submit(producer);
        service.submit(consumer);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {}
        service.shutdownNow();
    }
 
    public static void main(String[] args) {
        BlockingQueueTest.testBasket();
    }
}

上述就是小編為大家分享的java中隊列的介紹和使用了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。