Java ArrayBlockingQueue

在本教程中，我們將借助示例來學習ArrayBlockingQueue類及其方法。

Java Collections框架的ArrayBlockingQueue類提供了使用數(shù)組的阻塞隊列實現(xiàn)。

它實現(xiàn)了Java BlockingQueue接口。

創(chuàng)建ArrayBlockingQueue

為了創(chuàng)建一個數(shù)組阻塞隊列，我們必須導入java.util.concurrent.ArrayBlockingQueue包。

導入包后，可以使用以下方法在Java中創(chuàng)建數(shù)組阻塞隊列：

ArrayBlockingQueue<Type> animal = new ArrayBlockingQueue<>(int capacity);

這里，

• Type - 數(shù)組阻塞隊列的類型

• capacity - 數(shù)組阻塞隊列的大小

例如，

//創(chuàng)建大小為5的字符串類型ArrayBlockingQueue
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

//創(chuàng)建大小為5的整數(shù)類型ArrayBlockingQueue
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

注意：必須提供數(shù)組的大小。

ArrayBlockingQueue的方法

ArrayBlockingQueue類提供了BlockingQueue接口中所有方法的實現(xiàn)。

另外，我們將學習兩個方法put()和take()，它們支持數(shù)組阻塞隊列中的阻塞操作。

這兩種方法將數(shù)組阻塞隊列與其他典型隊列區(qū)分開來。

插入元素

• add() - 將指定的元素插入數(shù)組阻塞隊列。如果隊列已滿，它將拋出異常。

• offer() - 將指定的元素插入數(shù)組阻塞隊列。如果隊列已滿，則返回false。

例如，

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        //使用 add()
        animals.add("Dog");
        animals.add("Cat");

        //使用 offer()
        animals.offer("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);
    }
}

輸出結果

ArrayBlockingQueue: [Dog, Cat, Horse]

訪問元素

• peek() - 從數(shù)組阻塞隊列的前面返回一個元素。如果隊列為空，則返回null。

• iterator() - 返回一個迭代器對象，按順序訪問數(shù)組阻塞隊列中的元素。如果隊列為空，則拋出異常。我們必須導入java.util.Iterator軟件包才能使用它。

例如，

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        //添加元素
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);

        // 使用 peek()
        String element = animals.peek();
        System.out.println("訪問元素: " + element);

        // 使用 iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayBlockingQueue 元素: ");

        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

輸出結果

ArrayBlockingQueue: [Dog, Cat, Horse]
訪問元素: Dog
ArrayBlockingQueue 元素: Dog, Cat, Horse,

刪除元素

• remove() - 返回并從數(shù)組阻塞隊列中刪除指定的元素。如果隊列為空，則拋出異常。

• poll() - 返回并從數(shù)組阻塞隊列中刪除指定的元素。如果隊列為空，則返回null。

• clear() - 從數(shù)組阻塞隊列中刪除所有元素。

例如，

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);

        // 使用 remove()
        String element1 = animals.remove();
        System.out.println("刪除元素:");
        System.out.println("使用 remove(): " + element1);

        // 使用 poll()
        String element2 = animals.poll();
        System.out.println("使用 poll(): " + element2);

        // 使用 clear()
        animals.clear();
        System.out.println("更新后的ArrayBlockingQueue: " + animals);
    }
}

輸出結果

ArrayBlockingQueue: [Dog, Cat, Horse]
刪除元素:
使用 remove(): Dog
使用 poll(): Cat
更新后的ArrayBlockingQueue: []

put() 和 take()方法

在多線程進程中，我們可以使用put()和take()來阻塞一個線程的操作，從而使其與另一個線程同步。這些方法將等待，直到它們能夠成功執(zhí)行。

put()方法

要將元素添加到數(shù)組阻塞隊列的末尾，可以使用put()方法。

如果陣列阻塞隊列已滿，它將等待直到數(shù)組阻塞隊列中有足夠的空間來添加元素。

例如，

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
           //添加元素到animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

輸出結果

ArrayBlockingQueue: [Dog, Cat]

在這里，如果put()方法在等待時被中斷，則可能會拋出InterruptedException。 因此，我們必須將其包含在try..catch塊中。

take()方法

要從數(shù)組阻塞隊列的前面返回并刪除一個元素，我們可以使用take()方法。

如果數(shù)組阻塞隊列為空，它將等待，直到數(shù)組阻塞隊列中有要刪除的元素為止。

例如，

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
           //添加元素到animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);

           //刪除一個元素
           String element = animals.take();
           System.out.println("被刪除的元素: " + element);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

輸出結果

ArrayBlockingQueue: [Dog, Cat]
被刪除的元素: Dog

在這里，如果take()方法在等待過程中被中斷，它將拋出InterrupedException異常。因此，我們必須把它封裝在一個try…catch塊。

其他方法

為什么要使用ArrayBlockingQueue？

ArrayBlockingQueue使用數(shù)組作為其內部存儲。

它被認為是線程安全的集合。因此，它通常用于多線程應用程序中。

假設一個線程正在將元素插入隊列，而另一個線程正在從隊列中刪除元素。

現(xiàn)在，如果第一個線程比第二個線程慢，那么數(shù)組阻塞隊列可使第二個線程等待，直到第一個線程完成其操作。