Queue： 基本上，一個隊列就是一個先入先出（FIFO）的數(shù)據(jù)結構

Queue接口與List、Set同一級別，都是繼承了Collection接口。LinkedList實現(xiàn)了Deque接 口。

Queue的實現(xiàn)

1、沒有實現(xiàn)的阻塞接口的LinkedList： 實現(xiàn)了java.util.Queue接口和java.util.AbstractQueue接口

　　內置的不阻塞隊列： PriorityQueue 和 ConcurrentLinkedQueue
　　PriorityQueue 和 ConcurrentLinkedQueue 類在 Collection Framework 中加入兩個具體集合實現(xiàn)。
　　PriorityQueue 類實質上維護了一個有序列表。加入到 Queue 中的元素根據(jù)它們的天然排序（通過其 java.util.Comparable 實現(xiàn)）或者根據(jù)傳遞給構造函數(shù)的 java.util.Comparator 實現(xiàn)來定位。
　　ConcurrentLinkedQueue 是基于鏈接節(jié)點的、線程安全的隊列。并發(fā)訪問不需要同步。因為它在隊列的尾部添加元素并從頭部刪除它們，所以只要不需要知道隊列的大 小，ConcurrentLinkedQueue 對公共集合的共享訪問就可以工作得很好。收集關于隊列大小的信息會很慢，需要遍歷隊列。

2)實現(xiàn)阻塞接口的：

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

　　* ArrayBlockingQueue ：一個由數(shù)組支持的有界隊列。
　　* LinkedBlockingQueue ：一個由鏈接節(jié)點支持的可選有界隊列。
　　* PriorityBlockingQueue ：一個由優(yōu)先級堆支持的無界優(yōu)先級隊列。
　　* DelayQueue ：一個由優(yōu)先級堆支持的、基于時間的調度隊列。
　　* SynchronousQueue ：一個利用 BlockingQueue 接口的簡單聚集（rendezvous）機制。

下表顯示了jdk1.5中的阻塞隊列的操作：

　　add          增加一個元索                           如果隊列已滿，則拋出一個IIIegaISlabEepeplian異常
　　remove    移除并返回隊列頭部的元素     如果隊列為空，則拋出一個NoSuchElementException異常
　　element   返回隊列頭部的元素                如果隊列為空，則拋出一個NoSuchElementException異常
　　offer         添加一個元素并返回true         如果隊列已滿，則返回false
　　poll          移除并返問隊列頭部的元素     如果隊列為空，則返回null
　　peek        返回隊列頭部的元素                如果隊列為空，則返回null
　　put           添加一個元素                          如果隊列滿，則阻塞
　　take         移除并返回隊列頭部的元素     如果隊列為空，則阻塞

remove、element、offer、poll、peek其實是屬于Queue接口。

阻塞隊列的操作可以根據(jù)它們的響應方式分為以下三類：aad、removee和element操作在你試圖為一個已滿的隊列增加元素或從空隊列取得元素時 拋出異常。當然，在多線程程序中，隊列在任何時間都可能變成滿的或空的，所以你可能想使用offer、poll、peek方法。這些方法在無法完成任務時 只是給出一個出錯示而不會拋出異常。

注意：poll和peek方法出錯進返回null。因此，向隊列中插入null值是不合法的

最后，我們有阻塞操作put和take。put方法在隊列滿時阻塞，take方法在隊列空時阻塞。

LinkedBlockingQueue的容量是沒有上限的（說的不準確，在不指定時容量為Integer.MAX_VALUE，不要然的話在put時怎么會受阻呢），但是也可以選擇指定其最大容量，它是基于鏈表的隊列，此隊列按 FIFO（先進先出）排序元素。

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

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

DelayQueue（基于PriorityQueue來實現(xiàn)的）是一個存放Delayed 元素的無界阻塞隊列，只有在延遲期滿時才能從中提取元素。該隊列的頭部是延遲期滿后保存時間最長的 Delayed 元素。如果延遲都還沒有期滿，則隊列沒有頭部，并且poll將返回null。當一個元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一個小于或等于零的值時，則出現(xiàn)期滿，poll就以移除這個元素了。此隊列不允許使用 null 元素。

一個例子：

package com.yao;
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{
 // 籃子，能夠容納3個蘋果
 BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);

 // 生產(chǎn)蘋果，放入籃子
 public void produce() throws InterruptedException{
 // put方法放入一個蘋果，若basket滿了，等到basket有位置
 basket.put("An apple");
 }
 // 消費蘋果，從籃子中取走
 public String consume() throws InterruptedException{
 // get方法取出一個蘋果，若basket為空，等到basket有蘋果為止
 String apple = basket.take();
 return apple;
 }

 public int getAppleNumber(){
 return basket.size();
 }

 }
 //　測試方法
 public static void testBasket() {
 // 建立一個裝蘋果的籃子
 final Basket basket = new Basket();
 // 定義蘋果生產(chǎn)者
 class Producer implements Runnable {
 public void run() {
 try {
 while (true) {
 // 生產(chǎn)蘋果
 System.out.println("生產(chǎn)者準備生產(chǎn)蘋果：" 
 + System.currentTimeMillis());
 basket.produce();
 System.out.println("生產(chǎn)者生產(chǎn)蘋果完畢：" 
 + System.currentTimeMillis());
 System.out.println("生產(chǎn)完后有蘋果："+basket.getAppleNumber()+"個");
 // 休眠300ms
 Thread.sleep(300);
 }
 } catch (InterruptedException ex) {
 }
 }
 }
 // 定義蘋果消費者
 class Consumer implements Runnable {
 public void run() {
 try {
 while (true) {
 // 消費蘋果
 System.out.println("消費者準備消費蘋果：" 
 + System.currentTimeMillis());
 basket.consume();
 System.out.println("消費者消費蘋果完畢：" 
 + System.currentTimeMillis());
 System.out.println("消費完后有蘋果："+basket.getAppleNumber()+"個");
 // 休眠1000ms
 Thread.sleep(1000);
 }
 } catch (InterruptedException ex) {
 }
 }
 }

 ExecutorService service = Executors.newCachedThreadPool();
 Producer producer = new Producer();
 Consumer consumer = new Consumer();
 service.submit(producer);
 service.submit(consumer);
 // 程序運行10s后，所有任務停止
 try {
 Thread.sleep(10000);
 } catch (InterruptedException e) {
 }
 service.shutdownNow();
 }
 public static void main(String[] args) {
 BlockingQueueTest.testBasket();
 }
}

到此這篇關于java隊列之queue用法實例分析的文章就介紹到這了,更多相關java隊列 queue 內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論