Java 数组阻塞队列

Java ArrayBlockingQueue

在本教程中，我们将通过示例了解 ArrayBlockingQueue 类及其方法。

ArrayBlockingQueue Java Collections 框架的类提供了使用数组的阻塞队列实现。

它实现了Java BlockingQueue接口。

创建 ArrayBlockingQueue

为了创建数组阻塞队列，我们必须导入 java.util.concurrent.ArrayBlockingQueue 包。

导入包后，下面是我们如何在 Java 中创建数组阻塞队列：

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

在这里，

类型 - 数组阻塞队列的类型
容量 - 数组阻塞队列的大小

例如，

// Creating String type ArrayBlockingQueue with size 5
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

// Creating Integer type ArrayBlockingQueue with size 5
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

注意： 必须提供数组的大小。

ArrayBlockingQueue的方法

ArrayBlockingQueue 类提供了BlockingQueue中所有方法的实现界面。

这些方法用于在数组阻塞队列中插入、访问和删除元素。

另外，我们将学习两种方法 put() 和 take() 支持数组阻塞队列中的阻塞操作。

这两种方法将数组阻塞队列与其他典型队列区分开来。

插入元素

add() - 将指定元素插入数组阻塞队列。如果队列已满，则会引发异常。
offer() - 将指定元素插入数组阻塞队列。它返回 false 如果队列已满。

例如，

import java.util.concurrent.ArrayBlockingQueue;

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

        // Using add()
        animals.add("Dog");
        animals.add("Cat");

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

输出

ArrayBlockingQueue: [Dog, Cat, Horse]

访问元素

peek() - 从数组阻塞队列的前面返回一个元素。它返回 null 如果队列为空。
iterator() - 返回一个迭代器对象以顺序访问数组阻塞队列中的元素。如果队列为空，它会抛出异常。我们必须导入 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);

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

        // Using peek()
        String element = animals.peek();
        System.out.println("Accessed Element: " + element);

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayBlockingQueue Elements: ");

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

输出

ArrayBlockingQueue: [Dog, Cat, Horse]
Accessed Element: Dog
ArrayBlockingQueue Elements: Dog, Cat, Horse,

删除元素

remove() - 从数组阻塞队列中返回并删除指定元素。如果队列为空，则会引发异常。
poll() - 从数组阻塞队列中返回并删除指定元素。它返回 null 如果队列为空。
clear() - 从数组阻塞队列中移除所有元素。

例如，

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);

        // Using remove()
        String element1 = animals.remove();
        System.out.println("Removed Element:");
        System.out.println("Using remove(): " + element1);

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

        // Using clear()
        animals.clear();
        System.out.println("Updated ArrayBlockingQueue: " + animals);
    }
}

输出

ArrayBlockingQueue: [Dog, Cat, Horse]
Removed Elements:
Using remove(): Dog
Using poll(): Cat
Updated ArrayBlockingQueue: []

put() 和 take() 方法

在多线程进程中，我们可以使用 put() 和 take() 阻止一个线程的操作以使其与另一个线程同步。这些方法会一直等到可以成功执行。

put() 方法

要将元素添加到数组阻塞队列的末尾，我们可以使用 put() 方法。

如果数组阻塞队列已满，则等待数组阻塞队列有空间添加元素。

例如，

import java.util.concurrent.ArrayBlockingQueue;

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

       try {
        // Add elements to 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() 方法

要从数组阻塞队列的前面返回和删除一个元素，我们可以使用 take() 方法。

如果数组阻塞队列为空，则等待直到数组阻塞队列中有元素被删除。

例如，

import java.util.concurrent.ArrayBlockingQueue;

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

       try {
           //Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);

           // Remove an element
           String element = animals.take();
           System.out.println("Removed Element: " + element);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

输出

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

在这里，take() 方法将抛出一个 InterrupedException 如果在等待时被中断。因此，我们必须将它包含在 try...catch 中块。

其他方法

方法	说明
`contains(element)`	在数组阻塞队列中搜索指定元素。如果找到该元素，则返回`true` ，如果不是，则返回 `false` .
`size()`	返回数组阻塞队列的长度。
`toArray()`	将数组阻塞队列转换为数组并返回。
`toString()`	将数组阻塞队列转换为字符串

为什么要使用 ArrayBlockingQueue？

ArrayBlockingQueue 使用数组作为其内部存储。

它被认为是线程安全的 收藏。因此，它通常用于多线程应用程序中。

假设，一个线程正在向队列中插入元素，而另一个线程正在从队列中移除元素。

现在，如果第一个线程比第二个线程慢，那么数组阻塞队列可以让第二个线程等待，直到第一个线程完成它的操作。

Java 阻塞队列 Java LinkedBlockingQueue

java