ArrayBlockingQueue基于数组实现，容量固定，使用单锁机制，适合高内存效率和严格容量控制的场景；LinkedBlockingQueue基于链表实现，可选有界或默认无界，采用双锁分离读写，提升高并发吞吐量，但可能增加内存开销与GC压力，适用于高并发、需弹性缓冲的场景。选择应根据容量需求、并发程度及资源限制权衡。
Java中
ArrayBlockingQueue
和
LinkedBlockingQueue
的核心区别在于它们的底层数据结构、容量处理方式以及并发控制机制，这直接影响了它们在不同场景下的性能表现和资源消耗。简而言之，
ArrayBlockingQueue
是基于数组实现的有界阻塞队列，容量固定；而
LinkedBlockingQueue
是基于链表实现的阻塞队列，默认情况下是无界的，也可以指定容量。
解决方案
深入来看，这两种队列虽然都实现了
BlockingQueue
底层实现与容量管理：
ArrayBlockingQueue
顾名思义，其内部使用一个循环数组来存储元素。这意味着它的容量在创建时就必须指定，且之后无法改变。这种固定大小的特性，在某些场景下是优点，比如你明确知道需要一个上限来防止资源耗尽。但缺点也很明显，一旦队列满了，生产者就会被阻塞；队列空了，消费者就会被阻塞。
立即学习“Java免费学习笔记（深入）”；
LinkedBlockingQueue
则不同，它使用链表结构来存储元素，每个元素都是一个独立的
对象。当你创建它时，可以选择指定一个容量，使其成为一个有界队列；如果不安容量，它会默认使用
Integer.MAX_VALUE
作为容量，这在实际应用中几乎可以看作是无界的。这种无界特性让生产者在大多数情况下都能顺利添加元素，很少会因为队列满而被阻塞，但这也带来了潜在的风险：如果消费者处理速度跟不上，队列可能会无限增长，最终导致内存溢出（OOM）。
并发控制与锁机制： 这是两者在性能表现上产生差异的关键点。
ArrayBlockingQueue
为了保证线程安全，内部只使用了一个
ReentrantLock
来保护所有的入队（put）和出队（take）操作。这意味着无论生产者还是消费者，在操作队列时都需要获取同一个锁。在高并发环境下，如果生产者和消费者都在频繁地操作队列，这个单一的锁就会成为瓶颈，导致严重的锁竞争（contention），从而降低吞吐量。
LinkedBlockingQueue
的设计则更加巧妙。它内部维护了两个独立的
ReentrantLock
：一个用于入队操作（
putLock
），另一个用于出队操作（
takeLock
）。这意味着生产者和消费者可以在大多数情况下并行地操作队列，互不干扰。这种“读写分离”的锁机制，显著降低了锁竞争，使得
LinkedBlockingQueue
在高并发场景下通常能表现出更高的吞吐量。
内存消耗：
ArrayBlockingQueue
由于使用数组，其内存分配是连续的。对于存储较小的元素类型，它可能在内存效率上略胜一筹，因为它避免了链表结构中每个节点额外的对象开销（
Node
对象本身及其指向下一个节点的引用）。
LinkedBlockingQueue
的每个元素都需要封装在一个
Node
对象中，这个
Node
对象会包含实际元素以及指向下一个
Node
的引用。这意味着即使存储同样数量的元素，
LinkedBlockingQueue
也会比
ArrayBlockingQueue
消耗更多的内存。此外，频繁的入队出队操作还会导致更多的
Node
对象创建和销毁，增加垃圾回收（GC）的压力。
什么时候应该选择ArrayBlockingQueue？
在实际开发中，我个人觉得
ArrayBlockingQueue
往往被低估了，但它在特定场景下其实非常有用。
你选择
ArrayBlockingQueue
的主要理由，通常是当你对队列的容量有明确且严格的上限要求时。比如，你正在设计一个固定大小的线程池，希望限制同时等待处理的任务数量，防止任务无限堆积耗尽系统资源。这时，
ArrayBlockingQueue
的固定容量特性就成了天然的流量控制手段。它会强制生产者在队列满时阻塞，这是一种背压（backpressure）机制，能有效防止上游系统生产过快，导致下游系统过载。
另一个考虑点是内存使用。如果你的队列中存储的元素数量相对较少，并且对内存效率有较高要求，
ArrayBlockingQueue
可能会是更好的选择。由于其底层是数组，内存是连续分配的，这在某些情况下对CPU缓存更友好，可能带来更好的局部性（locality），进而提升性能。当然，这通常是在性能调优的非常细致的层面才会体现出来。
最后，如果你的应用场景并发度不是特别高，或者说，生产者和消费者操作队列的频率不是那么极端，那么
ArrayBlockingQueue
的单锁机制带来的竞争开销可能并不明显，其简洁和确定性反而成了优势。我见过很多系统，其实根本达不到需要双锁机制来优化的并发量，这时候用
ArrayBlockingQueue
反而更直接、更可控。
LinkedBlockingQueue在哪些场景下更具优势？
LinkedBlockingQueue
在多数情况下，尤其是在处理高并发和异步任务流时，是我个人更倾向于使用的选择，但前提是要理解其潜在的风险。
它的最大优势在于处理高并发的能力。由于采用了分离锁的设计（
putLock
和
takeLock
），生产者和消费者几乎可以完全并行地操作队列，极大地减少了锁竞争。这对于那些吞吐量要求极高、生产者和消费者数量都很多的应用场景来说，比如消息中间件的内部队列、高并发日志收集系统、或者需要快速响应的异步任务调度器，
LinkedBlockingQueue
能够提供更平滑、更高效的数据流转。
其次，
LinkedBlockingQueue
的默认无界特性，使得生产者在大多数情况下不会被阻塞。这在处理突发流量（burst traffic）时非常有用。例如，一个Web服务器接收请求的队列，如果瞬间涌入大量请求，
LinkedBlockingQueue
可以先将这些请求缓存起来，让消费者（工作线程）慢慢处理，避免了请求被直接拒绝。这种弹性对于保证服务的可用性至关重要。
当然，这种“无界”的灵活性也伴随着风险，即如果消费者处理速度长期低于生产者，队列会无限膨胀，最终耗尽内存。所以，在使用
LinkedBlockingQueue
时，如果选择无界，必须确保消费者有足够的能力消化掉所有数据，或者在更上层有其他的流量控制机制。如果实在无法保证，那么最好还是指定一个合理的容量，让它成为一个有界队列，利用其双锁的并发优势，同时避免内存溢出。
性能考量与实际应用中的权衡
选择
ArrayBlockingQueue
还是
LinkedBlockingQueue
，从来都不是一个简单的“哪个更快”的问题，它更多的是一个关于权衡和匹配应用场景的艺术。
锁竞争与吞吐量： 这可能是最显著的性能差异点。
ArrayBlockingQueue
的单锁设计，在生产者和消费者都非常活跃时，确实会成为瓶颈。想象一下，几十个线程都在抢一个锁，那性能下降是必然的。而
LinkedBlockingQueue
通过双锁，将入队和出队操作的竞争隔离开来，使得在高并发下，它的吞吐量通常会更高。我曾经遇到过一个系统，仅仅是将
ArrayBlockingQueue
换成
LinkedBlockingQueue
（且指定了相同容量），在高压测试下，整体的响应时间就有了明显的改善，这很大程度上就是锁竞争减少的功劳。
内存使用与GC压力：
ArrayBlockingQueue
的内存是预分配的连续块，一旦创建，内存占用相对稳定。而
LinkedBlockingQueue
的节点对象创建和销毁是动态的，每个元素都会产生一个额外的
Node
对象开销。这意味着，如果你的队列中存储的是大量的小对象，并且这些对象被频繁地添加和移除，
LinkedBlockingQueue
可能会导致更多的GC活动，进而影响应用程序的暂停时间（pause time）。对于内存敏感或者对GC延迟要求极高的应用，这一点是需要认真考虑的。
初始化与容量管理：
ArrayBlockingQueue
强制你在一开始就思考容量，这其实是一种很好的设计约束，能避免很多潜在的内存问题。而
LinkedBlockingQueue
的默认无界，虽然提供了便利，但也是一个“陷阱”。我见过不少新手开发者，因为不理解其默认行为，导致队列无限增长最终OOM的案例。所以，即使选择
LinkedBlockingQueue
，也强烈建议在构造时指定一个合理的容量，除非你真的非常确定你的消费者能够处理所有流入的数据。
缓存局部性：
ArrayBlockingQueue
基于数组，数据在内存中是连续存放的，这对于CPU缓存来说是非常友好的。当CPU访问一个元素时，很可能它周围的元素也已经被加载到缓存中，从而提高访问效率。
LinkedBlockingQueue
的节点则可能分散在内存的各个角落，缓存命中率可能不如
ArrayBlockingQueue
。但这通常是在处理大量数据且对极致性能有要求时才需要考虑的微观优化。
最终的选择，真的要回到你的具体业务场景。你需要一个严格控制大小的缓冲区吗？你的应用并发度有多高？你对内存消耗和GC延迟的容忍度是多少？这些问题没有标准答案，只有在实际分析和测试中才能找到最合适的方案。
评论（已关闭）
评论已关闭