Java面试要点111 - Java BlockingQueue实现原理

最新推荐文章于 2025-08-18 22:47:43 发布

原创

最新推荐文章于 2025-08-18 22:47:43 发布 · 1k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#java #面试 #android

在这里插入图片描述

文章目录

引言

BlockingQueue是Java并发包中的重要组件，它在生产者-消费者场景中发挥着关键作用。作为线程安全的队列实现，BlockingQueue不仅提供了普通队列操作，还支持阻塞操作，使其成为并发编程中不可或缺的工具。

一、BlockingQueue基本概念

BlockingQueue在Java中是一个接口，它扩展了Queue接口，提供了阻塞的插入和获取操作。当队列满时，插入操作将被阻塞；当队列空时，获取操作将被阻塞。这种特性使其特别适合于生产者-消费者模式的实现。

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

public class BlockingQueueBasics {
   
   
    public static void demonstrateBasicOperations() {
   
   
        // 创建一个容量为3的ArrayBlockingQueue
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
        
        try {
   
   
            // 添加元素的不同方式
            queue.put("First");  // 阻塞式添加
            queue.offer("Second");  // 非阻塞式添加
            boolean success = queue.offer("Third", 1, TimeUnit.SECONDS);  // 限时添加
            
            System.out.println("队列大小: " + queue.size());
            
            // 获取元素的不同方式
            String item1 = queue.take();  // 阻塞式获取
            String item2 = queue.poll();  // 非阻塞式获取
            String item3 = queue.poll(1, TimeUnit.SECONDS);  // 限时获取
            
        } catch (InterruptedException e) {
   
   
            Thread.currentThread().interrupt();
        }
    }
}

二、主要实现类解析

2.1 ArrayBlockingQueue实现原理

ArrayBlockingQueue是一个由数组支持的有界阻塞队列。它使用ReentrantLock来保证线程安全，使用Condition来实现线程等待和唤醒机制。

public class ArrayBlockingQueueAnalysis {
   
   
    static class CustomArrayBlockingQueue<E> {
   
   
        private final Object[] items;
        private final ReentrantLock lock;
        private final Condition notEmpty;
        private final Condition notFull;
        private int takeIndex;
        private int putIndex;
        private int count;
        
        public CustomArrayBlockingQueue(int capacity) {
   
   
            this.items = new Object[capacity];
            this.lock = new ReentrantLock(true);  // 使用公平锁
            this.notEmpty = lock.newCondition();
            this.notFull = lock.newCondition();
        }
        
        public void put(E e) throws InterruptedException {
   
   
            lock.lock();
            try {
   
   
                while (count == items.length) {
   
   
                    // 队列满时等待
                    notFull.await();
                }
                items[putIndex] = e;
                putIndex = (putIndex + 1) % items.length;
                count++;
                // 通知等待的消费者
                notEmpty.signal();
            } finally {
   
   
                lock.