Deque 深度解析

Java并发包（JUC）Deque深度解析

一、核心特性与定位

1.1 线程安全双端队列

JUC（java.util.concurrent）包中的Deque实现提供高效的线程安全双端操作，支持在队列头部和尾部进行插入/删除，适用于生产者-消费者模型、任务调度等并发场景。

1.2 核心特性矩阵

二、主要实现类解析

2.1 LinkedBlockingDeque

类结构：

public class LinkedBlockingDeque<E> extends AbstractQueue<E>
    implements BlockingDeque<E>, java.io.Serializable {

    // 内部节点类
    static class Node<E> {
        E item;
        Node<E> prev;
        Node<E> next;
        Node(E x) { item = x; }
    }

    // 头尾指针与计数器
    private transient Node<E> head;
    private transient Node<E> last;
    private transient int count;

    // 容量限制
    private final int capacity;

    // 锁与条件变量
    private final ReentrantLock putLock = new ReentrantLock();
    private final Condition notFull = putLock.newCondition();
    private final ReentrantLock takeLock = new ReentrantLock();
    private final Condition notEmpty = takeLock.newCondition();

    // 构造器
    public LinkedBlockingDeque(int capacity) {
        this.capacity = capacity;
    }

    // 核心方法：尾部插入（阻塞）
    public void putLast(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        Node<E> node = new Node<>(e);
        putLock.lockInterruptibly();
        try {
            while (count == capacity)
                notFull.await(); // 队列满时阻塞
            enqueue(node); // 插入尾部
        } finally {
            putLock.unlock();
        }
    }

    // 核心方法：头部取出（阻塞）
    public E takeFirst() throws InterruptedException {
        takeLock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await(); // 队列空时阻塞
            return dequeue(); // 移除头部
        } finally {
            takeLock.unlock();
        }
    }

    // 内部方法：入队
    private void enqueue(Node<E> node) {
        last = last.next = node;
        node.prev = last;
        count++;
        notEmpty.signal(); // 唤醒等待的消费者
    }

    // 内部方法：出队
    private E dequeue() {
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        count--;
        notFull.signal(); // 唤醒等待的生产者
        return x;
    }
}

底层结构：

• 基于链表实现
• 可选容量限制（默认Integer.MAX_VALUE）
• 头尾双锁（ReentrantLock分段锁）

典型场景：

// 任务队列（固定大小）
BlockingDeque<Task> taskQueue = new LinkedBlockingDeque<>(1024);

// 生产者
taskQueue.putFirst(new Task()); // 阻塞插入队首

// 消费者
Task task = taskQueue.takeLast(); // 阻塞从队尾获取

性能调优：

// 调整公平锁策略（默认非公平）
new LinkedBlockingDeque<>(1024, true);

// 监控队列状态
int remainingCapacity = taskQueue.remainingCapacity();

2.2 ConcurrentLinkedDeque

类结构：

public class ConcurrentLinkedDeque<E> extends AbstractQueue<E>
    implements Deque<E>, java.io.Serializable {

    // 内部节点类
    private static class Node<E> {
        volatile E item;
        volatile Node<E> prev;
        volatile Node<E> next;

        Node(E x) { item = x; }
    }

    // 头尾指针
    private transient volatile Node<E> head;
    private transient volatile Node<E> tail;

    // 核心方法：尾部插入
    public boolean addLast(E e) {
        if (e == null) throw new NullPointerException();
        Node<E> node = new Node<>(e);
        for (Node<E> t = tail, p = t;;) { // 自旋尝试插入
            Node<E> q = p.next;
            if (q == null) { // 尾部为空，直接插入
                if (p.casNext(null, node)) {
                    if (p != t) // 更新尾指针（CAS 失败时回退）
                        casTail(t, node);
                    return true;
                }
            } else if (p == q) // 尾节点被移除，重新定位
                p = (t != (t = tail)) ? t : head;
            else // 向前遍历找到实际尾部
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

    // 核心方法：头部取出
    public E removeFirst() {
        for (;;) {
            Node<E> h = head;
            Node<E> first = h.next;
            if (h == head && first != null) { // 定位头部节点
                E item = first.item;
                if (item != null && first.casItem(item, null)) { // CAS 置空 item
                    if (first.next == null) // 更新头指针
                        casHead(h, first);
                    else
                        casHead(h, first.next);
                    return item;
                }
            } else if (h == head) { // 队列为空
                return null;
            }
        }
    }

    // CAS 更新尾指针
    private boolean casTail(Node<E> cmp, Node<E> val) {
        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
    }

    // CAS 更新头指针
    private boolean casHead(Node<E> cmp, Node<E> val) {
        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
    }
}

底层结构：

• 基于CAS的无锁链表
• 使用头尾指针优化并发访问
• 弱一致性迭代器

典型场景：

// 日志消息队列（无界）
Deque<LogEntry> logQueue = new ConcurrentLinkedDeque<>();

// 高并发写入
logQueue.addFirst(new LogEntry()); // 非阻塞插入队首

// 批量消费
Iterator<LogEntry> it = logQueue.descendingIterator();
while(it.hasNext()) {
    process(it.next());
    it.remove(); // 需显式删除
}

高级特性：

// 原子更新操作
logQueue.offerFirst(entry); // 插入失败返回false
logQueue.pollLast();        // 获取并移除队尾元素

三、关键使用场景

3.1 工作窃取算法

实现原理：

// ForkJoinPool任务窃取
ForkJoinPool pool = new ForkJoinPool();
pool.invoke(new RecursiveTask<Integer>() {
    protected Integer compute() {
        if (workQueue.isEmpty()) {
            // 从其他线程队列尾部窃取任务
            return pool.getQueuedTaskCount() > 0 ? 
                ((RecursiveTask) pool.poll()).compute() : 0;
        }
        return process(workQueue.pollFirst());
    }
});

优势：

• 减少线程竞争
• 提高CPU利用率
• 天然支持双端操作

3.2 历史记录回放

实现示例：

// 交易记录双端队列（固定大小）
Deque<Transaction> history = new LinkedBlockingDeque<>(1000);

// 添加记录
public void addHistory(Transaction t) {
    if (history.size() == 1000) {
        history.removeLast(); // 保持最大容量
    }
    history.addFirst(t);
}

// 回放操作
public void replay() {
    history.descendingIterator().forEachRemaining(this::execute);
}

四、性能对比与选型

4.1 基准测试数据

测试环境：

• 48核Xeon处理器
• JDK 17
• 100%写入场景

吞吐量对比（ops/ms）：

延迟对比（纳秒）：

4.2 选型建议

1. 需要阻塞操作 → 选择LinkedBlockingDeque
2. 追求极致低延迟 → 选择ConcurrentLinkedDeque
3. 固定容量场景 → 优先LinkedBlockingDeque
4. 无界队列需求 → 使用ConcurrentLinkedDeque

五、高级模式与陷阱

5.1 双端协作模式

实现示例：

// 任务优先级队列
Deque<Task> highPriority = new ConcurrentLinkedDeque<>();
Deque<Task> normalPriority = new LinkedBlockingDeque<>();

// 生产者
if (task.isCritical()) {
    highPriority.addFirst(task);
} else {
    normalPriority.put(task);
}

// 消费者（双端消费）
while (!highPriority.isEmpty()) {
    process(highPriority.pollLast()); // 优先处理高优先级
}
while (!normalPriority.isEmpty()) {
    process(normalPriority.take());    // 处理普通任务
}

5.2 常见陷阱规避

陷阱1：迭代器失效

// 错误示范
for (Task t : deque) {
    if (t.isExpired()) {
        deque.remove(t); // 抛出ConcurrentModificationException
    }
}

// 正确做法
Iterator<Task> it = deque.iterator();
while(it.hasNext()) {
    Task t = it.next();
    if (t.isExpired()) {
        it.remove(); // 使用迭代器自身remove方法
    }
}

陷阱2：容量误用

// 错误示范（无界队列导致OOM）
Deque<byte[]> buffer = new ConcurrentLinkedDeque<>();

// 正确做法（设置合理容量）
Deque<byte[]> buffer = new LinkedBlockingDeque<>(10_000);

六、注意事项

1. LinkedBlockingDeque：
   • 容量需合理设置，避免频繁阻塞/唤醒。
   • 锁粒度较细，但高竞争时仍可能成为瓶颈。
2. ConcurrentLinkedDeque：
   • 无界队列需防止内存溢出。
   • CAS 失败时通过自旋重试，需避免长时间循环导致 CPU 占用过高。

七、总结

• LinkedBlockingDeque 通过双锁和条件变量实现阻塞队列，适合需要严格容量控制的场景。
• ConcurrentLinkedDeque 通过无锁算法实现高性能并发，适合读多写少的高并发场景。
• 两者均严格实现 Deque 接口，但底层机制差异显著，需根据业务需求选择。

理解其源码有助于在并发编程中合理选择双端队列实现，避免性能瓶颈。