是的,Java标准库(JDK)中提供了多个阻塞队列,可以直接使用。这些阻塞队列位于java.util.concurrent
包中。阻塞队列是一种支持在某些操作无法立即完成时等待的队列,例如在队列为空时执行的take
操作,或者在队列已满时执行的put
操作。
以下是JDK中几种常见的阻塞队列及其特点:
1. ArrayBlockingQueue
ArrayBlockingQueue
是一个基于数组的有界阻塞队列。其特点如下:
- 固定大小(在创建时指定)。
- FIFO(先进先出)顺序。
- 可以指定公平性策略,以确保等待的线程按FIFO顺序访问队列。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ArrayBlockingQueueExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
// Producer
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
queue.put(i);
System.out.println("Produced: " + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
// Consumer
new Thread(() -> {
try {
while (true) {
Integer item = queue.take();
System.out.println("Consumed: " + item);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
}
2. LinkedBlockingQueue
LinkedBlockingQueue
是一个基于链表的可选有界阻塞队列。其特点如下:
- 可以指定大小,也可以默认大小(默认是Integer.MAX_VALUE)。
- FIFO顺序。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class LinkedBlockingQueueExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
// Producer
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
queue.put(i);
System.out.println("Produced: " + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
// Consumer
new Thread(() -> {
try {
while (true) {
Integer item = queue.take();
System.out.println("Consumed: " + item);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
}
3. PriorityBlockingQueue
PriorityBlockingQueue
是一个支持优先级的无界阻塞队列。其特点如下:
- 元素按照其自然顺序或者通过提供的比较器排序。
- 没有容量限制(无界)。
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class PriorityBlockingQueueExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> queue = new PriorityBlockingQueue<>();
// Producer
new Thread(() -> {
try {
for (int i = 10; i > 0; i--) {
queue.put(i);
System.out.println("Produced: " + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
// Consumer
new Thread(() -> {
try {
while (true) {
Integer item = queue.take();
System.out.println("Consumed: " + item);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
}
4. SynchronousQueue
SynchronousQueue
是一个不存储元素的阻塞队列。每个插入操作必须等待相应的移除操作,反之亦然。其特点如下:
- 不存储元素。
- 每个put操作必须等待一个take操作,反之亦然。
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.BlockingQueue;
public class SynchronousQueueExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> queue = new SynchronousQueue<>();
// Producer
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
queue.put(i);
System.out.println("Produced: " + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
// Consumer
new Thread(() -> {
try {
while (true) {
Integer item = queue.take();
System.out.println("Consumed: " + item);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
}
总结
Java的java.util.concurrent
包中提供了多种阻塞队列,包括ArrayBlockingQueue
、LinkedBlockingQueue
、PriorityBlockingQueue
和SynchronousQueue
,可以根据不同的使用场景选择合适的阻塞队列。这些队列实现了流式处理,支持多线程环境下的高效数据传输和同步。