在Java中，有哪些常见的阻塞队列实现？

八股文_Java集合面试题 0 56

参考回答**

在 Java 中，BlockingQueue 是 java.util.concurrent 包中提供的一个接口，用于在多线程环境下实现线程安全的队列。它定义了一系列支持 阻塞操作 的方法，主要用于 生产者-消费者模型。

BlockingQueue 的常见实现类如下：

1. ArrayBlockingQueue

特点：
- 基于数组的 有界阻塞队列，队列的容量在初始化时必须指定，不能动态扩容。
- 采用 FIFO（先进先出） 的顺序存储元素。
- 通过内部的锁机制保证线程安全。
适用场景：
- 适合生产者和消费者数量相对平衡的场景，避免内存无限增长。

示例：

import java.util.concurrent.ArrayBlockingQueue;

public class ArrayBlockingQueueExample {
  public static void main(String[] args) throws InterruptedException {
      ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);

      queue.put(1);
      queue.put(2);
      queue.put(3);
      // queue.put(4); // 阻塞等待，直到队列有空位

      System.out.println(queue.take()); // 输出：1
      System.out.println(queue.take()); // 输出：2
  }
}

2. LinkedBlockingQueue

特点：
- 基于链表的 阻塞队列。
- 可以是有界（指定容量）或无界（默认最大容量为 Integer.MAX_VALUE）。
- 在吞吐量方面通常高于 ArrayBlockingQueue，因为其内部使用了 分离锁机制（一个用于生产者，一个用于消费者）。
适用场景：
- 适合高吞吐量的场景，如任务队列、日志记录等。

示例：

import java.util.concurrent.LinkedBlockingQueue;

public class LinkedBlockingQueueExample {
  public static void main(String[] args) throws InterruptedException {
      LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(3);

      queue.put(1);
      queue.put(2);
      queue.put(3);
      // queue.put(4); // 阻塞等待

      System.out.println(queue.take()); // 输出：1
      System.out.println(queue.take()); // 输出：2
  }
}

3. PriorityBlockingQueue

特点：
- 基于优先级的 无界阻塞队列。
- 队列中的元素会根据其优先级（通过 Comparator 或元素的自然顺序）进行排序。
- 由于是无界的，使用时需要注意内存占用问题。
适用场景：
- 需要按照优先级顺序处理任务的场景，例如调度任务。

示例：

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueExample {
  public static void main(String[] args) {
      PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

      queue.add(20);
      queue.add(10);
      queue.add(30);

      System.out.println(queue.poll()); // 输出：10
      System.out.println(queue.poll()); // 输出：20
      System.out.println(queue.poll()); // 输出：30
  }
}

4. DelayQueue

特点：
- 基于优先级队列的 无界阻塞队列。
- 队列中的元素必须实现 Delayed 接口，并按照 延迟到期时间 进行排序。
- 只有延迟到期的元素才能被取出，取元素前线程会阻塞。
适用场景：
- 需要延迟处理任务的场景，例如任务调度、定时器。

示例：

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

class DelayedElement implements Delayed {
  private final long delayTime;
  private final long expireTime;

  public DelayedElement(long delay, TimeUnit unit) {
      this.delayTime = unit.toMillis(delay);
      this.expireTime = System.currentTimeMillis() + this.delayTime;
  }

  @Override
  public long getDelay(TimeUnit unit) {
      return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
  }

  @Override
  public int compareTo(Delayed o) {
      return Long.compare(this.getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS));
  }

  @Override
  public String toString() {
      return "DelayedElement{" + "delayTime=" + delayTime + '}';
  }
}

public class DelayQueueExample {
  public static void main(String[] args) throws InterruptedException {
      DelayQueue<DelayedElement> queue = new DelayQueue<>();

      queue.put(new DelayedElement(3, TimeUnit.SECONDS));
      queue.put(new DelayedElement(1, TimeUnit.SECONDS));

      System.out.println(queue.take()); // 等待 1 秒输出
      System.out.println(queue.take()); // 等待 2 秒输出
  }
}

5. SynchronousQueue

特点：
- 无缓冲阻塞队列，即每次 put() 必须等待 take()，生产者和消费者直接交互。
- 不存储任何元素，适合生产者和消费者严格一对一的场景。
- 内部支持公平模式和非公平模式。
适用场景：
- 生产者和消费者之间需要直接交互的场景。

示例：

import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueExample {
  public static void main(String[] args) {
      SynchronousQueue<String> queue = new SynchronousQueue<>();

      new Thread(() -> {
          try {
              System.out.println("Putting A...");
              queue.put("A");
              System.out.println("Putting B...");
              queue.put("B");
          } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
          }
      }).start();

      new Thread(() -> {
          try {
              System.out.println("Taking: " + queue.take());
              System.out.println("Taking: " + queue.take());
          } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
          }
      }).start();
  }
}

6. LinkedTransferQueue

特点：
- 高性能的无界阻塞队列，支持生产者直接将数据传递给消费者（“转移”操作）。
- 如果没有消费者等待时，数据会被存储在队列中。
- 提供了 tryTransfer 和 transfer 方法，支持消费者主动获取数据。
适用场景：
- 高并发任务队列或需要直接数据传递的场景。

示例：

import java.util.concurrent.LinkedTransferQueue;

public class LinkedTransferQueueExample {
  public static void main(String[] args) throws InterruptedException {
      LinkedTransferQueue<String> queue = new LinkedTransferQueue<>();

      new Thread(() -> {
          try {
              System.out.println("Taking: " + queue.take());
          } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
          }
      }).start();

      Thread.sleep(1000);
      queue.transfer("A"); // 等待消费者处理
      System.out.println("Transferred A");
  }
}

7. LinkedBlockingDeque

特点：
- 基于链表的 双端阻塞队列。
- 支持在队列的两端插入和删除元素（例如 addFirst()、addLast()）。
- 可以是有界或无界。
适用场景：
- 需要双端队列支持的场景，如双向任务调度。

示例：

import java.util.concurrent.LinkedBlockingDeque;

public class LinkedBlockingDequeExample {
  public static void main(String[] args) throws InterruptedException {
      LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>(3);

      deque.putFirst(1);
      deque.putLast(2);

      System.out.println(deque.takeFirst()); // 输出：1
      System.out.println(deque.takeLast());  // 输出：2
  }
}

阻塞队列的对比

实现类	有界/无界	特点
`ArrayBlockingQueue`	有界	基于数组，容量固定，FIFO 顺序，性能适中。
`LinkedBlockingQueue`	有界/无界	基于链表，吞吐量高，适合高并发场景。
`PriorityBlockingQueue`	无界	基于优先级排序，元素按自然顺序或自定义顺序存储。
`DelayQueue`	无界	按延迟时间排序的队列，适合定时任务。
`SynchronousQueue`	无缓冲	无存储能力，生产者和消费者直接交互，适合一对一通信。
`LinkedTransferQueue`	无界	高性能队列，支持直接传递和存储。
`LinkedBlockingDeque`	有界/无界	支持双端操作，适合双向任务调度。

总结

在 Java 中，阻塞队列的实现包括：

基于数组：ArrayBlockingQueue。
基于链表：LinkedBlockingQueue、LinkedBlockingDeque。
特殊功能队列：
- 优先级：PriorityBlockingQueue。
- 延迟：DelayQueue。
- 无缓冲：SynchronousQueue。
- 高并发：LinkedTransferQueue。

选择建议：

有界队列：ArrayBlockingQueue 或 LinkedBlockingQueue。
无缓冲队列：SynchronousQueue。
需要排序：PriorityBlockingQueue。
定时任务：DelayQueue。
高并发或直接数据传递：LinkedTransferQueue。