跳到主要内容

Java ArrayBlockingQueue

提示
  1. ArrayBlockingQueue基本概念：Java中的ArrayBlockingQueue是基于数组实现的阻塞队列，属于Java集合框架的一部分，主要用于多线程环境。
  2. ArrayBlockingQueue的创建和方法：通过指定队列大小来创建ArrayBlockingQueue。它提供了标准的队列操作方法，如add(), offer(), peek(), remove(), poll()，以及两个特殊的阻塞方法put()和take()。
  3. ArrayBlockingQueue的应用场景：由于其线程安全的特性，ArrayBlockingQueue适用于多线程应用，特别是生产者-消费者场景，其中一个线程添加元素，另一个线程从队列中取出元素，提供了线程间的同步机制。

Java 集合框架中的 ArrayBlockingQueue 类使用数组提供阻塞队列的实现。

它实现了 Java BlockingQueue 接口。

ArrayBlockingQueue 实现了 Java 中的 BlockingQueue 接口。

创建 ArrayBlockingQueue​

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

一旦我们导入了该包，下面是在 Java 中创建数组阻塞队列的方法：

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

这里，

  • Type - 数组阻塞队列的类型
  • capacity - 数组阻塞队列的大小

例如，

// 创建大小为 5 的 String 类型 ArrayBlockingQueue
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

// 创建大小为 5 的 Integer 类型 ArrayBlockingQueue
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);

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

        // 使用 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);

        // 添加元素
        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() - 返回并从数组阻塞队列中移除一个指定元素。如果队列为空，则抛出异常。
  • 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);

        // 使用 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() 来阻塞一个线程的操作，以便与另一个线程同步。这些方法会等待直到它们可以成功执行。

put() 方法​

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

如果数组阻塞队列已满，它会等待直到数组阻塞队列中有空间来添加元素。

例如，

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() 方法​

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

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

例如，

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 块中。

其他方法​

方法描述
contains(element)搜索数组阻塞队列中的指定元素。如果找到该元素，返回 true，否则返回 false。
size()返回数组阻塞队列的长度。
toArray()将数组阻塞队列转换为数组并返回。

|

| toString() | 将数组阻塞队列转换为字符串 |

为什么使用 ArrayBlockingQueue？​

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

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

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

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

最后于 更新