Java队列红绿灯法则：阻塞是秩序，非阻塞是自由-优快云博客

本文链接：https://blog.youkuaiyun.com/static_coder/article/details/148782057

01 引言

在并发编程的世界里，线程间的数据交换如同繁忙都市中的交通流。阻塞队列与非阻塞队列，恰似交通信号灯与自由通行市场的差异，它们以不同的策略管理着数据的“车流”。

秩序的安全性与自由的快速响应在各自的领域闪闪发光，我们一起了解一下吧！

02 阻塞队列

阻塞队列的核心思想是 “没有空间？请等待！没有数据？请等待！”，直到有数据来才会继续向下执行，我们先一睹为快。

2.1 示例代码

public class QuqueTest {
	// 定义一个阻塞队列
    BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);

    @Test
    void test01() throws InterruptedException {
        Timer timer = new Timer();
        // 5s之后向队列中添加数据
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                try {
                    queue.put(1);
                    queue.put(2);
                    queue.put(3);
                    queue.put(4);
                    System.out.println(DateUtil.now() + " queue队列执被取出，继续添加队列");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, 5000);

        System.out.println(DateUtil.now() + " invoke queue.take()");
        // 从队列中获取值
        Integer take = queue.take();
        System.out.println(DateUtil.now() + " take=" + take);
    }
}

先来看看效果：

2.2 代码解析

案例代码中定义了一个队列长度为3的阻塞队列。当队列增加的数量达到3时，第4个put()就会阻塞，直到有队列中有数据取出时，阻塞结束，继续添加元素。

阻塞队列中取值时，如果队列中没有值时，同样take()方法也会阻塞，直到有数据进入，才能取出值，继续后续流程。

案例中启用了定时器，5s后才会向队列中添加元素。当代码执行到queue.take()就会阻塞，直到5s后元素被添加，才会继续向下执行。

然而从日志来看，put()方法的阻塞并没有体现出来，我们可以在 Integer take = queue.take();方法之前增加一个睡眠，保证添加动作优先完成。

这里就可以看出，5s之后并没有打印出队列添加的日志，而是在7s之后执行的，说明put()也被阻塞了。

源码到底怎么实现的呢？

阻塞队列的put()通过加锁的方式保证线程的安全，当队列的数据等于初始化的长度时，当前线程就是阻塞进入等待，直到被其他线程唤醒才会继续执行。而take()方中的dequeue就可以唤醒阻塞的线程。

2.3 核心实现类

ArrayBlockingQueue：基于数组的有界队列，固定容量。

LinkedBlockingQueue：基于链表的可选有界队列（默认Integer.MAX_VALUE）。

PriorityBlockingQueue：支持优先级排序的无界队列。

SynchronousQueue：不存储元素的特殊队列，生产者和消费者必须“手递手”交换数据。

DelayQueue：延迟队列。

2.4 应用场景

线程池的任务调度：ThreadPoolExecutor默认使用的就是LinkedBlockingQueue管理待执行的任务。
生产者-消费者模型：生产者填数据，消费者取数据，队列满/空时自动协调。
资源池管理：如数据库连接池，当无可用连接时请求线程阻塞等待。

03 非阻塞队列

非阻塞队列采用 “无锁（Lock-Free）或乐观锁” 机制（如CAS），就像一个高效的自由市场。

3.1 示例代码

ConcurrentLinkedQueue<Integer> queue2 = new ConcurrentLinkedQueue<>();

@Test
void test02() throws InterruptedException {
    Integer poll = queue2.poll();
    System.out.println(DateUtil.now() + " poll=" +poll);

    queue2.add(1);
    System.out.println(DateUtil.now() + " poll=" +queue2.poll());
}

这里的代码非常简单，能取到值就是取，取不到就是null。

3.2 代码解析

代码虽然简单，但是有一个关键的技术CAS。我们通过add()方法进入看看：

如图所示，就是CAS的体现， compareAndSet（CAS）是保障线程安全的核心原子操作。因为该方法是有CPU执行直接保证的，我们无法看到具体的实现，通过伪代码了解下：

// 伪代码：CAS 操作原理
boolean compareAndSet(对象引用, int 预期值, int 新值) {
    if (当前内存值 == 预期值) { // 检查是否被其他线程修改
        将内存值更新为新值;   // 若未被修改则安全更新
        return true;
    }
    return false; // 修改失败
}

CAS最大程度上的保证了无锁状态下的线程安全，在保证快速的同时最大程度的保证了安全性，但是仍然对于A→B→A无法解决。

04 关键差异

特性	阻塞队列	非阻塞队列
同步机制	基于锁（ReentrantLock）	无锁，CAS操作
线程阻塞	put/take操作可能阻塞线程	offer/poll永不阻塞
吞吐量	中高（锁优化后）	极高（无锁并发）
适用场景	需要严格协调的生产者-消费者	高并发读/写，短暂竞争可接受
边界控制	通常有界	通常“无界”（受内存限制）