Java中Queue实现类详解

本文最后更新于 2025-11-19，文章内容可能已经过时。

Queue接口的主要实现类

Java标准库中java.util.Queue接口的主要实现类包括：

AbstractQueue (抽象类，其他实现通常继承自它)
ArrayDeque (双端队列实现)
LinkedList (双端队列实现)
PriorityQueue (优先级队列)
ConcurrentLinkedQueue (并发非阻塞队列)
ArrayBlockingQueue (有界阻塞队列)
LinkedBlockingQueue (可选有界阻塞队列)
PriorityBlockingQueue (并发优先级队列)
DelayQueue (延迟队列)
SynchronousQueue (同步移交队列)

各类Queue的最佳适用场景及使用示例

1. ArrayDeque

适用场景：高性能通用队列/栈，不需要线程安全的场景。性能优于Stack和LinkedList。

import java.util.ArrayDeque;
import java.util.Queue;

public class ArrayDequeExample {
    public static void main(String[] args) {
        // 创建ArrayDeque作为队列使用
        Queue<String> queue = new ArrayDeque<>();
        
        // 添加元素
        queue.offer("First");
        queue.offer("Second");
        queue.offer("Third");
        
        // 检查头部元素
        System.out.println("Head element: " + queue.peek()); // First
        
        // 逐个移除并处理元素
        while (!queue.isEmpty()) {
            System.out.println("Processing: " + queue.poll());
        }
        
        // 作为栈使用
        ArrayDeque<String> stack = new ArrayDeque<>();
        stack.push("A");
        stack.push("B");
        stack.push("C");
        System.out.println("Stack pop: " + stack.pop()); // C
    }
}

2. PriorityQueue

适用场景：需要按照元素优先级处理的场景，如任务调度、事件处理系统。

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

public class PriorityQueueExample {
    static class Task implements Comparable<Task> {
        private int priority;
        private String name;
        
        public Task(int priority, String name) {
            this.priority = priority;
            this.name = name;
        }
        
        @Override
        public int compareTo(Task other) {
            return Integer.compare(this.priority, other.priority);
        }
        
        @Override
        public String toString() {
            return "Task{name='" + name + "', priority=" + priority + "}";
        }
    }
    
    public static void main(String[] args) {
        // 创建优先级队列
        Queue<Task> taskQueue = new PriorityQueue<>();
        
        // 添加不同优先级的任务
        taskQueue.offer(new Task(3, "Low priority task"));
        taskQueue.offer(new Task(1, "High priority task"));
        taskQueue.offer(new Task(2, "Medium priority task"));
        
        // 处理任务（按优先级顺序）
        System.out.println("Processing tasks by priority:");
        while (!taskQueue.isEmpty()) {
            System.out.println(taskQueue.poll());
        }
    }
}

3. ArrayBlockingQueue

适用场景：生产者-消费者模型，需要有界队列控制内存使用，如任务池、连接池。

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

public class ArrayBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建容量为5的有界阻塞队列
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
        
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 生产者线程
        executor.submit(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i); // 如果队列满，将阻塞
                    System.out.println("Produced: " + i);
                    Thread.sleep(100);
                }
                queue.put(-1); // 用-1作为结束标记
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        // 消费者线程
        executor.submit(() -> {
            try {
                while (true) {
                    Integer value = queue.take(); // 如果队列空，将阻塞
                    if (value == -1) break; // 结束标记
                    System.out.println("Consumed: " + value);
                    Thread.sleep(300);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        executor.shutdown();
        // 等待线程执行完成
        Thread.sleep(5000);
    }
}

4. ConcurrentLinkedQueue

适用场景：高并发环境下需要高性能的非阻塞队列，如事件处理、消息传递。

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建并发安全的非阻塞队列
        Queue<String> concurrentQueue = new ConcurrentLinkedQueue<>();
        
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        // 多个生产者
        for (int i = 0; i < 4; i++) {
            final int producerId = i;
            executor.submit(() -> {
                for (int j = 0; j < 5; j++) {
                    String item = "Producer-" + producerId + "-Item-" + j;
                    concurrentQueue.offer(item);
                    System.out.println("Added: " + item);
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            });
        }
        
        // 消费者
        executor.submit(() -> {
            while (!concurrentQueue.isEmpty() || !executor.isShutdown()) {
                String item = concurrentQueue.poll();
                if (item != null) {
                    System.out.println("Consumed: " + item);
                }
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        
        executor.shutdown();
        Thread.sleep(3000);
    }
}

5. DelayQueue

适用场景：需要延迟处理的场景，如缓存过期、定时任务、重试机制。

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

public class DelayQueueExample {
    static class DelayedTask implements Delayed {
        private final String name;
        private final long startTime; // 任务可执行的时间点（毫秒）
        
        public DelayedTask(String name, long delayMillis) {
            this.name = name;
            this.startTime = System.currentTimeMillis() + delayMillis;
        }
        
        @Override
        public long getDelay(TimeUnit unit) {
            long diff = startTime - System.currentTimeMillis();
            return unit.convert(diff, TimeUnit.MILLISECONDS);
        }
        
        @Override
        public int compareTo(Delayed other) {
            if (other instanceof DelayedTask) {
                return Long.compare(this.startTime, ((DelayedTask) other).startTime);
            }
            return 0;
        }
        
        @Override
        public String toString() {
            return "DelayedTask{name='" + name + "', startTime=" + startTime + "}";
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();
        
        // 添加不同延迟时间的任务
        delayQueue.put(new DelayedTask("Task-1", 5000)); // 5秒后执行
        delayQueue.put(new DelayedTask("Task-2", 2000)); // 2秒后执行
        delayQueue.put(new DelayedTask("Task-3", 8000)); // 8秒后执行
        
        System.out.println("Tasks added to DelayQueue. Waiting for execution...");
        
        // 处理延迟任务
        while (!delayQueue.isEmpty()) {
            DelayedTask task = delayQueue.take(); // 阻塞直到有任务到期
            System.out.println("Executed at " + System.currentTimeMillis() + ": " + task.name);
        }
    }
}

6. SynchronousQueue

适用场景：需要直接传递元素的场景，如线程池中的任务移交，一个线程生产、另一个线程立即消费。

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SynchronousQueueExample {
    public static void main(String[] args) {
        // 创建同步队列
        SynchronousQueue<String> syncQueue = new SynchronousQueue<>();
        
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 生产者
        executor.submit(() -> {
            try {
                System.out.println("Producer waiting to hand over item 1");
                syncQueue.put("Item-1"); // 阻塞直到有消费者接收
                System.out.println("Item 1 handed over");
                
                Thread.sleep(1000);
                
                System.out.println("Producer waiting to hand over item 2");
                syncQueue.put("Item-2"); // 阻塞直到有消费者接收
                System.out.println("Item 2 handed over");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        // 消费者
        executor.submit(() -> {
            try {
                Thread.sleep(500); // 稍微延迟，让生产者先等待
                System.out.println("Consumer ready to take item");
                String item1 = syncQueue.take(); // 阻塞直到有生产者提供
                System.out.println("Consumer received: " + item1);
                
                Thread.sleep(1500);
                
                System.out.println("Consumer ready to take next item");
                String item2 = syncQueue.take(); // 阻塞直到有生产者提供
                System.out.println("Consumer received: " + item2);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        executor.shutdown();
    }
}

总结

队列类型	线程安全	阻塞	有界/无界	最佳适用场景
ArrayDeque	否	否	无界	高性能通用队列/栈
LinkedList	否	否	无界	需频繁在中间插入/删除元素
PriorityQueue	否	否	无界	按优先级处理元素
ConcurrentLinkedQueue	是	否	无界	高并发非阻塞场景
ArrayBlockingQueue	是	是	有界	有界生产者-消费者模型
LinkedBlockingQueue	是	是	可选有界	高吞吐量生产者-消费者
PriorityBlockingQueue	是	是	无界(实际受限)	并发环境下的优先级队列
DelayQueue	是	是	无界	延迟执行任务
SynchronousQueue	是	是	无容量	直接移交操作、线程池任务传递

根据具体应用场景选择合适的队列实现，可以显著提高系统性能和代码可维护性。