在Java多线程开发中，队列是常用的数据结构，用于线程间的消息传递、任务缓存等场景，但普通的非线程安全队列在并发读写时会出现数据覆盖、索引越界等问题，需要通过特定的设计或选择已有的线程安全实现来保证操作的正确性。
Java中内置的线程安全队列类型
Java在java.util.concurrent包中提供了多种现成的线程安全队列，开发者可以直接根据场景选择，不需要自己从零实现同步逻辑，常见的类型分为非阻塞队列和阻塞队列两类。
非阻塞线程安全队列
非阻塞队列基于CAS（Compare And Swap）机制实现，不需要加锁，性能通常优于阻塞队列，适合并发量高、不需要阻塞等待元素的场景，最常用的是ConcurrentLinkedQueue。
以下是ConcurrentLinkedQueue的基础使用示例：
import java.util.concurrent.ConcurrentLinkedQueue;
public class NonBlockingQueueDemo {
public static void main(String[] args) {
// 创建非阻塞线程安全队列
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
// 入队操作，非阻塞，失败返回false
boolean offerResult = queue.offer("任务1");
System.out.println("入队结果：" + offerResult);
// 出队操作，非阻塞，队列为空返回null
String pollResult = queue.poll();
System.out.println("出队元素：" + pollResult);
// 获取队首元素但不移除，队列为空返回null
String peekResult = queue.peek();
System.out.println("队首元素：" + peekResult);
}
}
阻塞线程安全队列
阻塞队列在队列为空时取元素会阻塞等待，队列满时存元素会阻塞等待，适合生产者消费者模型，常用的实现类有ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等。
以下是ArrayBlockingQueue的生产者消费者示例：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo {
public static void main(String[] args) {
// 创建容量为5的阻塞队列
BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
// 生产者线程
Thread producer = new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
String task = "任务" + i;
// 队列满时会阻塞等待
queue.put(task);
System.out.println("生产者放入：" + task);
Thread.sleep(100);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
// 消费者线程
Thread consumer = new Thread(() -> {
try {
while (true) {
// 队列空时会阻塞等待
String task = queue.take();
System.out.println("消费者取出：" + task);
Thread.sleep(300);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
producer.start();
consumer.start();
}
}
自定义线程安全队列的实现方式
如果内置队列无法满足特殊需求，也可以自己实现线程安全队列，核心思路是对队列的读写操作加锁，或者使用CAS机制保证原子性。
基于ReentrantLock的实现
使用显式锁ReentrantLock可以对队列的入队、出队操作加锁，保证同一时间只有一个线程能修改队列结构，以下是简单的实现示例：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
public class CustomSafeQueue<T> {
private final List<T> data = new ArrayList<>();
private final ReentrantLock lock = new ReentrantLock();
// 入队操作，加锁保证线程安全
public void offer(T element) {
lock.lock();
try {
data.add(element);
} finally {
lock.unlock();
}
}
// 出队操作，加锁保证线程安全
public T poll() {
lock.lock();
try {
if (data.isEmpty()) {
return null;
}
return data.remove(0);
} finally {
lock.unlock();
}
}
// 获取队列大小
public int size() {
lock.lock();
try {
return data.size();
} finally {
lock.unlock();
}
}
}
线程安全队列的设计经验
在实际开发中使用或设计线程安全队列时，可以参考以下经验：
- 优先选择JDK内置的线程安全队列，避免重复造轮子，内置队列经过大量场景验证，稳定性和性能都更有保障。
- 根据业务场景选择队列类型：如果是高并发无阻塞场景选
ConcurrentLinkedQueue，如果是生产者消费者模型选阻塞队列，如果需要优先级排序选PriorityBlockingQueue。 - 注意队列的容量设置，有界队列可以避免内存溢出，无界队列在生产者速度远快于消费者时可能导致OOM。
- 操作队列时如果需要批量处理，尽量将批量操作放在同一个锁范围内，避免多次加锁带来的性能损耗。
- 不要在队列中存储过大的对象，避免占用过多内存，同时出队后如果对象不再使用，及时解除引用方便GC回收。
常见问题与避坑点
很多开发者在使用线程安全队列时会遇到一些常见问题，需要注意规避：
- 不要认为线程安全队列的所有操作都是原子的，比如先判断
size() > 0再调用poll()，这两个操作之间可能有其他线程修改了队列，导致poll()返回null，需要把判断和操作放在同一个原子逻辑中。 - 阻塞队列的
take()方法会响应中断，抛出InterruptedException，使用时需要正确处理中断逻辑，不要忽略异常。 - 自定义队列时如果使用读写锁，要注意读锁和写锁的互斥逻辑，避免读写并发导致的数据不一致问题。
Java多线程安全队列ConcurrentLinkedQueueBlockingQueue修改时间：2026-06-24 09:15:38