跳到主要内容

Java LinkedBlockingQueue

提示
  1. 实现与应用：LinkedBlockingQueue 是基于链表实现的阻塞队列，用于多线程环境中的线程安全数据交换。
  2. 创建与方法：可创建无或有固定容量的 LinkedBlockingQueue，支持基本操作如插入、访问、移除元素。
  3. 特殊方法：put() 和 take() 方法用于在多线程中进行同步操作，等待直到可以插入或移除元素。

Java Collections 框架中的 LinkedBlockingQueue 类使用链表实现了阻塞队列。

它实现了 Java BlockingQueue 接口。

ArrayBlockingQueue 在 Java 中实现了 BlockingQueue 接口。

创建 LinkedBlockingQueue​

为了创建一个链式阻塞队列，我们必须导入 java.util.concurrent.LinkedBlockingQueue 包。

以下是在 Java 中创建链式阻塞队列的方法：

1. 不指定初始容量

LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>();

这里默认的初始容量将是 2^31-1。

2. 指定初始容量

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

这里，

  • Type - 链式阻塞队列的类型
  • capacity - 链式阻塞队列的大小

例如，

// 创建容量为 5 的 String 类型 LinkedBlockingQueue
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);

// 创建容量为 5 的 Integer 类型 LinkedBlockingQueue
LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>(5);

注意： 不强制要求提供链表的大小。

LinkedBlockingQueue 的方法​

LinkedBlockingQueue 类实现了 BlockingQueue 接口 中的所有方法。

这些方法用于向链式阻塞队列插入、访问和删除元素。

此外，我们还将学习两个支持链式阻塞队列中阻塞操作的方法 put() 和 take()。

这两个方法使链式阻塞队列与其他典型队列有所区别。

插入元素​

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

例如，

import java.util.concurrent.LinkedBlockingQueue;

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

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

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

输出

LinkedBlockingQueue: [Dog, Cat, Horse]

访问元素​

  • peek() - 返回链式阻塞队列前端的一个元素。如果队列为空，则返回 null。
  • iterator() - 返回一个迭代器对象，用于顺序访问链式阻塞队列中的元素。如果队列为空，则抛出异常。使用它时必须导入 java.util.Iterator 包。

例如，

import java.util.concurrent.LinkedBlockingQueue;
import java.util.Iterator;

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

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

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

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

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

输出

LinkedBlockingQueue: [Dog, Cat, Horse]
访问的元素：Dog
LinkedBlockingQueue 元素：Dog, Cat, Horse,

移除元素​

  • remove() - 返回并移除链式阻塞队列中指定的元素。如果队列为空，则抛出异常。
  • poll() - 返回并移除链式阻塞队列中指定的元素。如果队列为空，则返回 null。
  • clear() - 移除链式阻塞队列中的所有元素。

例如，

import java.util.concurrent.LinkedBlockingQueue;

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

        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("LinkedBlockingQueue " + 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("更新后的 LinkedBlockingQueue " + animals);
    }
}

输出

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

put() 和 take() 方法​

在多线程处理过程中，我们可以使用 put() 和 take() 来阻塞一个线程的操作，以便与另一个线程同步。这些方法将等待直到它们可以成功执行。

put() 方法​

要向链式阻塞队列末尾插入指定元素，我们使用 put() 方法。

如果链式阻塞队列已满，它会等待直到队列中有空间来插入元素。

例如，

import java.util.concurrent.LinkedBlockingQueue;

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

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

输出

LinkedBlockingQueue: [Dog, Cat]

这里，如果 put() 方法在等待时被中断，可能会抛出 InterruptedException。因此，我们必须将其包含在 try..catch 块中。

take() 方法​

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

如果链式阻塞队列为空，它会等待直到队列中有可删除的元素。

例如，

import java.util.concurrent.LinkedBlockingQueue;

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

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

           // 移除一个元素
           String element = animals.take();
           System.out.println("移除的元素: " + element);
           System.out.println("新的 LinkedBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

输出

LinkedBlockingQueue: [Dog, Cat]
移除的元素: Dog
新的 LinkedBlockingQueue: [Cat]

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

其他方法​

方法描述
contains(element)在链式阻塞队列中搜索指定元素。如果找到该元素，则返回 true，否则返回 false。
size()返回链式阻

塞队列的长度。 | | toArray() | 将链式阻塞队列转换为数组并返回该数组。 | | toString() | 将链式阻塞队列转换为字符串。 |

为什么使用 LinkedBlockingQueue？​

LinkedBlockingQueue 使用链表作为其内部存储。

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

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

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

最后于 更新