Java ArrayBlockingQueue

ArrayBlockingQueue 底层使用数组实现了阻塞队列。在本教程中，我们将借助示例了解 ArrayBlockingQueue 类及其用法。

在本教程中，我们将借助示例了解 ArrayBlockingQueue 类及其用法。

ArrayBlockingQueue 类实现了 Java BlockingQueue 接口，底层使用数组实现了有界的阻塞队列。

ArrayBlockingQueue 在 Java 中实现了 BlockingQueue 接口

创建 ArrayBlockingQueue

我们导入 java.util.concurrent.ArrayBlockingQueue 类后，就可以通过构造方法创建 ArrayBlockingQueue 对象了。

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

这里，

  • Type - ArrayBlockingQueue 泛型的类型参数，指定了队列中元素的数据类型。
  • capacity - ArrayBlockingQueue 的容量，必须的参数。

例如，

ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

注意： ArrayBlockingQueue 阻塞队列必须提供容量参数。

ArrayBlockingQueue 的方法

ArrayBlockingQueue 类完全实现了 BlockingQueue 接口提供的所有方法。

除了普通的插入、访问和删除元素，我们将学习 put() ， take() 两个方法，它们支持阻塞操作。这也是阻塞队列和其他普通队列的重要区别。

插入元素

  • add() - 将指定元素插入 ArrayBlockingQueue 。如果队列已满则抛出异常。
  • offer() - 将指定元素插入 ArrayBlockingQueue 。如果队列已满则返回 false。

例如，

import java.util.concurrent.ArrayBlockingQueue;

public 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() - 从 ArrayBlockingQueue 的队头返回一个元素。如果队列为空，则返回 null。
  • iterator() - 返回一个迭代器对象以顺序访问 ArrayBlockingQueue 中的元素。

例如，

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

public 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() - 从 ArrayBlockingQueue 中删除并返回指定的元素。如果队列为空，则抛出异常。
  • poll() - 从 ArrayBlockingQueue 中删除并返回指定的元素。如果队列为空，则返回 null。
  • clear() - 清空 ArrayBlockingQueue 中的所有元素。

例如，

import java.util.concurrent.ArrayBlockingQueue;

public 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 Element:
Using remove(): Dog
Using poll(): Cat
Updated ArrayBlockingQueue: []

put() 和 take() 方法

在多线程环境中，我们可以使用 put() 和 take() 来阻塞一个线程的操作，使其与另一个线程同步。这些阻塞方法会在操作不成功的时候一直等待，直到它们可以成功执行。

put() 方法

put() 方法将元素添加到 ArrayBlockingQueue 队尾。如果 ArrayBlockingQueue 已满，则一直等待到 ArrayBlockingQueue 中有空间再添加元素。

例如，

import java.util.concurrent.ArrayBlockingQueue;

public 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() 方法删除并返回 ArrayBlockingQueue 队列头部的元素。如果 ArrayBlockingQueue 为空，则一直等待直到 ArrayBlockingQueue 不空后再执行删除操作。

例如，

import java.util.concurrent.ArrayBlockingQueue;

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

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

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

何时使用 ArrayBlockingQueue？

ArrayBlockingQueue 使用数组作为其内部存储。ArrayBlockingQueue 被认为是一个线程安全的集合。因此，它通常用于多线程应用程序。

阻塞队列一个常用的场景是在生产者消费者模式中。

我们实现生产者消费者模式的时候，可以使用阻塞队列作为中间的产品仓库，生产者线程生产了产品之后会将产品放入仓库，消费者线程在需要的时候从仓库拿走产品。

如果生产的快而消费的慢，那么仓库（队列）满了之后，生产者线程就要等待仓库有空间才能放入新的产品。

如果生产的慢而消费的快，那么仓库（队列）空了之后，消费者线程就要等待仓库中有了产品之后才能拿走。

Java 阻塞队列 Java LinkedBlockingQueue