MySQL 基础配置与使用完全指南

Java 队列详细使用教程

一、Java 队列简介和核心概念

Java 队列是 Java 集合框架的重要组成部分，提供了高效的 FIFO（先进先出）数据结构。

核心接口

接口	说明
Queue	基础队列接口，提供 FIFO 操作
Deque	双端队列接口，支持两端插入和删除
BlockingQueue	阻塞队列接口，线程安全的队列

Queue 核心方法

二、LinkedList 队列使用

“`java
import java.util.LinkedList;
import java.util.Queue;

public class LinkedListQueueExample {
public static void main(String[] args) {
Queue queue = new LinkedList<>();

queue.offer(“A”);
queue.offer(“B”);
queue.offer(“C”);
System.out.println(“Queue: ” + queue);

String first = queue.peek();
System.out.println(“First: ” + first);

String removed = queue.poll();
System.out.println(“Removed: ” + removed);
System.out.println(“Size: ” + queue.size());
}
}


三、ArrayDeque 队列使用

java
import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeExample {
public static void main(String[] args) {
Deque deque = new ArrayDeque<>();

deque.offerLast(“A”);
deque.offerLast(“B”);
deque.offerFirst(“X”);
deque.offerFirst(“Y”);

System.out.println(“Deque: ” + deque);

String last = deque.pollLast();
String first = deque.pollFirst();

System.out.println(“Last: ” + last);
System.out.println(“First: ” + first);
}
}


四、PriorityQueue 优先队列

自然排序

java
import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
public static void main(String[] args) {
Queue queue = new PriorityQueue<>();

queue.offer(5);
queue.offer(2);
queue.offer(8);
queue.offer(1);
queue.offer(9);

while (!queue.isEmpty()) {
System.out.println(“Poll: ” + queue.poll());
}
}
}


自定义优先级

java
class Task implements Comparable {
private String name;
private int priority;

public Task(String name, int priority) {
this.name = name;
this.priority = priority;
}

@Override
public int compareTo(Task other) {
return Integer.compare(other.priority, this.priority);
}

public String toString() {
return “Task{name='” + name + “‘, priority=” + priority + “}”;
}
}

public class CustomPriorityQueue {
public static void main(String[] args) {
Queue taskQueue = new PriorityQueue<>();

taskQueue.offer(new Task(“低优先级”, 1));
taskQueue.offer(new Task(“高优先级”, 10));
taskQueue.offer(new Task(“中优先级”, 5));

while (!taskQueue.isEmpty()) {
System.out.println(“Processing: ” + taskQueue.poll());
}
}
}


五、BlockingQueue 阻塞队列

ArrayBlockingQueue

java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

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

queue.put(“A”);
queue.put(“B”);
queue.put(“C”);

System.out.println(“Size: ” + queue.size());

String item = queue.take();
System.out.println(“Taken: ” + item);
}
}


LinkedBlockingQueue

java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

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

queue.offer(“A”);
queue.offer(“B”);
queue.offer(“C”);

System.out.println(“Poll: ” + queue.poll());
System.out.println(“Poll: ” + queue.poll());
}
}


DelayQueue

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

class DelayedTask implements Delayed {
private String name;
private long delayTime;

public DelayedTask(String name, long delay, TimeUnit unit) {
this.name = name;
this.delayTime = System.currentTimeMillis() + unit.toMillis(delay);
}

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

@Override
public int compareTo(Delayed other) {
return Long.compare(this.delayTime, ((DelayedTask) other).delayTime);
}
}

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

queue.put(new DelayedTask(“Task 1”, 2, TimeUnit.SECONDS));
queue.put(new DelayedTask(“Task 2”, 1, TimeUnit.SECONDS));

while (!queue.isEmpty()) {
DelayedTask task = queue.take();
System.out.println(“Processing: ” + task.getName());
}
}
}


六、ConcurrentLinkedQueue 并发队列

java
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Iterator;

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

for (int i = 0; i < 10; i++) { queue.offer("Item-" + i); } Iterator iterator = queue.iterator();
while (iterator.hasNext()) {
System.out.println(“Item: ” + iterator.next());
}
}
}


七、生产者和消费者模式

java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class ProducerConsumer {
private final BlockingQueue queue = new LinkedBlockingQueue<>(10);

class Producer implements Runnable {
private int id;

public Producer(int id) {
this.id = id;
}

@Override
public void run() {
try {
for (int i = 0; i < 5; i++) { int item = id * 10 + i; queue.put(item); System.out.println("Produced: " + item); Thread.sleep(100); } } catch (InterruptedException e) { e.printStackTrace(); } } } class Consumer implements Runnable { @Override public void run() { try { while (true) { int item = queue.take(); System.out.println("Consumed: " + item); if (item % 50 == 0 && item != 0) { break; } } } catch (InterruptedException e) { e.printStackTrace(); } } } } public class Main { public static void main(String[] args) throws InterruptedException { ProducerConsumer pc = new ProducerConsumer(); Thread p1 = new Thread(pc.new Producer(1)); Thread p2 = new Thread(pc.new Producer(2)); Thread c = new Thread(pc.new Consumer()); p1.start(); p2.start(); c.start(); p1.join(); p2.join(); c.join(); } }


八、队列选择最佳实践

选择指南

| 场景 | 推荐队列 | 原因 |
|------|----------|------|
| 单线程 FIFO | LinkedList | 简单、高效 |
| 双端操作 | ArrayDeque | 性能更好 |
| 优先级处理 | PriorityQueue | 自动排序 |
| 多线程同步 | BlockingQueue | 线程安全 |
| 高并发无界 | ConcurrentLinkedQueue | 无锁高性能 |

使用建议

java
// ✅ 推荐：使用接口类型
Queue queue = new ArrayBlockingQueue<>(10);
Queue queue = new PriorityQueue<>();

// ❌ 不推荐：使用实现类
ArrayBlockingQueue queue = new ArrayBlockingQueue<>(10);

// ✅ 推荐：设置合理容量
BlockingQueue queue = new ArrayBlockingQueue<>(100);

// ❌ 不推荐：无界队列导致 OOM
BlockingQueue queue = new LinkedBlockingQueue<>();

// ✅ 推荐：处理阻塞异常
try {
queue.take();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}

// ✅ 推荐：使用超时
boolean added = queue.offer(item, 5, TimeUnit.SECONDS);
“`

—