java中Queue接口

時間  2019-11-22
標籤 java queue 接口 欄目 Java 简体版
原文   原文鏈接

　　Queue接口與List、Set同一級別，都是繼承了Collection接口。LinkedList實現了Queue接 口。Queue接口窄化了對LinkedList的方法的訪問權限（即在方法中的參數類型若是是Queue時，就徹底只能訪問Queue接口所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法），以使得只有恰當的方法纔可使用。BlockingQueue 繼承了Queue接口。前端

　　隊列是一種特殊的線性表，它只容許在表的前端（front）進行刪除操做，而在表的後端（rear）進行插入操做。進行插入操做的端稱爲隊尾，進行刪除操做的端稱爲隊頭。隊列中沒有元素時，稱爲空隊列。java

　　隊列是一種數據結構．它有兩個基本操做：在隊列尾部加人一個元素，和從隊列頭部移除一個元素就是說，隊列以一種先進先出的方式管理數據，若是你試圖向一個 已經滿了的阻塞隊列中添加一個元素或者是從一個空的阻塞隊列中移除一個元索，將致使線程阻塞．在多線程進行合做時，阻塞隊列是頗有用的工具。工做者線程可 以按期地把中間結果存到阻塞隊列中而其餘工做者線線程把中間結果取出並在未來修改它們。隊列會自動平衡負載。若是第一個線程集運行得比第二個慢，則第二個 線程集在等待結果時就會阻塞。若是第一個線程集運行得快，那麼它將等待第二個線程集遇上來。下表顯示了jdk1.5中的阻塞隊列的操做：後端

 

add        增長一個元索                     若是隊列已滿，則拋出一個IIIegaISlabEepeplian異常
remove   移除並返回隊列頭部的元素    若是隊列爲空，則拋出一個NoSuchElementException異常
element  返回隊列頭部的元素             若是隊列爲空，則拋出一個NoSuchElementException異常
offer       添加一個元素並返回true       若是隊列已滿，則返回false
poll         移除並返問隊列頭部的元素    若是隊列爲空，則返回null
peek       返回隊列頭部的元素             若是隊列爲空，則返回null
put         添加一個元素                      若是隊列滿，則阻塞
take        移除並返回隊列頭部的元素     若是隊列爲空，則阻塞數組

remove、element、offer 、poll、peek 實際上是屬於Queue接口。 數據結構

　　Queue使用時要儘可能避免Collection的add()和remove()方法，而是要使用offer()來加入元素，使用poll()來獲取並移出元素。它們的優勢是經過返回值能夠判斷成功與否，add()和remove()方法在失敗的時候會拋出異常。 若是要使用前端而不移出該元素，使用
element()或者peek()方法。多線程

　　值得注意的是LinkedList類實現了Queue接口，所以咱們能夠把LinkedList當成Queue來用。代碼以下：工具

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest {
    public static void main(String[] args) {
        //add()和remove()方法在失敗的時候會拋出異常(不推薦)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一個元素，並在隊列中刪除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一個元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一個元素 
        for(String q : queue){
            System.out.println(q);
        }
        
    }
}

　　阻塞隊列的操做能夠根據它們的響應方式分爲如下三類：aad、removee和element操做在你試圖爲一個已滿的隊列增長元素或從空隊列取得元素時 拋出異常。固然，在多線程程序中，隊列在任什麼時候間均可能變成滿的或空的，因此你可能想使用offer、poll、peek方法。這些方法在沒法完成任務時 只是給出一個出錯示而不會拋出異常。性能

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

 

　　還有帶超時的offer和poll方法變種，例如，下面的調用：
　　boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);
　　嘗試在100毫秒內向隊列尾部插入一個元素。若是成功，當即返回true；不然，當到達超時進，返回false。一樣地，調用：
　　Object head = q.poll(100, TimeUnit.MILLISECONDS);
　　若是在100毫秒內成功地移除了隊列頭元素，則當即返回頭元素；不然在到達超時時，返回null。spa

 

　　最後，咱們有阻塞操做put和take。put方法在隊列滿時阻塞，take方法在隊列空時阻塞。

 

　　java.ulil.concurrent包提供了阻塞隊列的4個變種。默認狀況下，LinkedBlockingQueue的容量是沒有上限的（說的不許確，在不指定時容量爲Integer.MAX_VALUE，不要然的話在put時怎麼會受阻呢），可是也能夠選擇指定其最大容量，它是基於鏈表的隊列，此隊列按 FIFO（先進先出）排序元素。


　　ArrayBlockingQueue在構造時須要指定容量， 並能夠選擇是否須要公平性，若是公平參數被設置true，等待時間最長的線程會優先獲得處理（其實就是經過將ReentrantLock設置爲true來 達到這種公平性的：即等待時間最長的線程會先操做）。一般，公平性會使你在性能上付出代價，只有在的確很是須要的時候再使用它。它是基於數組的阻塞循環隊 列，此隊列按 FIFO（先進先出）原則對元素進行排序。


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


　　最後，DelayQueue（基於PriorityQueue來實現的）是一個存放Delayed 元素的無界阻塞隊列，只有在延遲期滿時才能從中提取元素。該隊列的頭部是延遲期滿後保存時間最長的 Delayed 元素。若是延遲都尚未期滿，則隊列沒有頭部，而且poll將返回null。當一個元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一個小於或等於零的值時，則出現期滿，poll就以移除這個元素了。此隊列不容許使用 null 元素。 下面是延遲接口：

public interface Delayed extends Comparable<Delayed> {  
     long getDelay(TimeUnit unit);  
}

　　放入DelayQueue的元素還將要實現compareTo方法，DelayQueue使用這個來爲元素排序。

 

　　下面的實例展現瞭如何使用阻塞隊列來控制線程集。程序在一個目錄及它的全部子目錄下搜索全部文件，打印出包含指定關鍵字的文件列表。從下面實例能夠看出，使用阻塞隊列兩個顯著的好處就是：多線程操做共同的隊列時不須要額外的同步，另外就是隊列會自動平衡負載，即那邊（生產與消費兩邊）處理快了就會被阻塞掉，從而減小兩邊的處理速度差距。下面是具體實現：

public class BlockingQueueTest {  
    public static void main(String[] args) {  
        Scanner in = new Scanner(System.in);  
        System.out.print("Enter base directory (e.g. /usr/local/jdk5.0/src): ");  
        String directory = in.nextLine();  
        System.out.print("Enter keyword (e.g. volatile): ");  
        String keyword = in.nextLine();  
  
        final int FILE_QUEUE_SIZE = 10;// 阻塞隊列大小  
        final int SEARCH_THREADS = 100;// 關鍵字搜索線程個數  
  
        // 基於ArrayBlockingQueue的阻塞隊列  
        BlockingQueue<File> queue = new ArrayBlockingQueue<File>(  
                FILE_QUEUE_SIZE);  
  
        //只啓動一個線程來搜索目錄  
        FileEnumerationTask enumerator = new FileEnumerationTask(queue,  
                new File(directory));  
        new Thread(enumerator).start();  
          
        //啓動100個線程用來在文件中搜索指定的關鍵字  
        for (int i = 1; i <= SEARCH_THREADS; i++)  
            new Thread(new SearchTask(queue, keyword)).start();  
    }  
}  
class FileEnumerationTask implements Runnable {  
    //啞元文件對象，放在阻塞隊列最後，用來標示文件已被遍歷完  
    public static File DUMMY = new File("");  
  
    private BlockingQueue<File> queue;  
    private File startingDirectory;  
  
    public FileEnumerationTask(BlockingQueue<File> queue, File startingDirectory) {  
        this.queue = queue;  
        this.startingDirectory = startingDirectory;  
    }  
  
    public void run() {  
        try {  
            enumerate(startingDirectory);  
            queue.put(DUMMY);//執行到這裏說明指定的目錄下文件已被遍歷完  
        } catch (InterruptedException e) {  
        }  
    }  
  
    // 將指定目錄下的全部文件以File對象的形式放入阻塞隊列中  
    public void enumerate(File directory) throws InterruptedException {  
        File[] files = directory.listFiles();  
        for (File file : files) {  
            if (file.isDirectory())  
                enumerate(file);  
            else  
                //將元素放入隊尾，若是隊列滿，則阻塞  
                queue.put(file);  
        }  
    }  
}  
class SearchTask implements Runnable {  
    private BlockingQueue<File> queue;  
    private String keyword;  
  
    public SearchTask(BlockingQueue<File> queue, String keyword) {  
        this.queue = queue;  
        this.keyword = keyword;  
    }  
  
    public void run() {  
        try {  
            boolean done = false;  
            while (!done) {  
                //取出隊首元素，若是隊列爲空，則阻塞  
                File file = queue.take();  
                if (file == FileEnumerationTask.DUMMY) {  
                    //取出來後從新放入，好讓其餘線程讀到它時也很快的結束  
                    queue.put(file);  
                    done = true;  
                } else  
                    search(file);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (InterruptedException e) {  
        }  
    }  
    public void search(File file) throws IOException {  
        Scanner in = new Scanner(new FileInputStream(file));  
        int lineNumber = 0;  
        while (in.hasNextLine()) {  
            lineNumber++;  
            String line = in.nextLine();  
            if (line.contains(keyword))  
                System.out.printf("%s:%d:%s%n", file.getPath(), lineNumber,  
                        line);  
        }  
        in.close();  
    }  
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程