Java 菜鸟教程

Java 流程控制

Java 数组

Java 面向对象(I)

Java 面向对象(II)

Java 面向对象(III)

Java 异常处理

Java 列表(List)

Java Queue(队列)

Java Map集合

Java Set集合

Java 输入输出(I/O)

Java Reader/Writer

Java 其他主题

Java LinkedBlockingQueue

在本教程中,我们将借助示例来学习LinkedBLockingQueue类及其方法。

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的字符串类型LinkedBlockingQueue
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);

//创建大小为5的整数类型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("访问元素: " + element);

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

        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使用链表作为其内部存储。

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

假设一个线程正在将元素插入队列,而另一个线程正在从队列中删除元素。

现在,如果第一个线程比第二个线程慢,则链表阻塞队列可使第二个线程等待,直到第一个线程完成其操作。