如何获取ArrayBlockingQueue容量并将其缩减1？

首先，非常理解你的困扰——作为有界队列，ArrayBlockingQueue居然不提供直接获取总容量的方法，确实有点反直觉，尤其是在并发场景下没法用size() + getRemainingCapacity()来计算（两次调用间隙队列状态可能已经变化）。下面分几部分给你解答：

一、简便获取容量的方案 #

1. 反射直接读取私有capacity字段 #

这是最快速的解决方案，因为ArrayBlockingQueue的总容量是初始化后就固定的私有字段，我们可以用反射绕过访问限制拿到它：

import java.lang.reflect.Field;
import java.util.concurrent.ArrayBlockingQueue;

public class QueueUtils {
    public static int getQueueCapacity(ArrayBlockingQueue<?> queue) {
        try {
            Field capacityField = ArrayBlockingQueue.class.getDeclaredField("capacity");
            capacityField.setAccessible(true);
            return capacityField.getInt(queue);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            // 处理JDK版本变化导致字段不存在的情况
            throw new RuntimeException("Failed to get queue capacity", e);
        }
    }
}

注意事项：这种方法依赖JDK的内部实现细节，如果未来JDK修改了ArrayBlockingQueue的字段名或结构，代码会失效。但在当前主流JDK版本（8-17）中都是可行的，适合快速解决问题的场景。

2. 预先维护容量映射（更稳定） #

如果担心反射的兼容性问题，你可以在创建队列时就把容量记录下来，比如用一个线程安全的Map来关联队列和它的容量：

import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;

public class QueueManager {
    private static final Map<ArrayBlockingQueue<?>, Integer> QUEUE_CAPACITY_MAP = new ConcurrentHashMap<>();

    public static <E> ArrayBlockingQueue<E> createQueue(int capacity) {
        ArrayBlockingQueue<E> queue = new ArrayBlockingQueue<>(capacity);
        QUEUE_CAPACITY_MAP.put(queue, capacity);
        return queue;
    }

    public static int getQueueCapacity(ArrayBlockingQueue<?> queue) {
        Integer capacity = QUEUE_CAPACITY_MAP.get(queue);
        if (capacity == null) {
            throw new IllegalArgumentException("Queue not created by QueueManager");
        }
        return capacity;
    }
}

这种方法完全不依赖内部实现，稳定性更高，但需要确保所有队列都通过QueueManager创建，适合需要长期维护的项目。

二、关于ArrayBlockingQueue不暴露容量的设计考量 #

其实这个设计是有其合理性的，主要基于以下几点：

• 接口一致性：BlockingQueue接口并没有定义getCapacity方法，因为并非所有实现都是有界的（比如LinkedTransferQueue就是无界的）。作为实现类，ArrayBlockingQueue遵循接口设计，不额外暴露超出接口定义的方法，保持API的一致性。
• 封装性原则：总容量属于队列的内部实现细节，设计者认为用户在初始化队列时就应该自己记住这个值，不需要队列来提供。这样即使未来内部实现调整（比如换一种方式存储容量），也不会影响外部代码。
• 避免误用：并发场景下，总容量本身是固定值，但如果暴露这个方法，可能会让用户误以为可以用它来做一些并发安全的判断（比如结合size()计算剩余容量），而实际上这种计算在多线程环境下是不可靠的——这也是为什么size()方法在并发队列中通常只是一个估算值。

三、容量缩减的完整步骤 #

拿到容量后，你原来的思路就可以正常执行了，这里要注意drainTo方法是线程安全的（ArrayBlockingQueue内部用重入锁保证操作原子性），所以转移元素的过程中不会有并发问题：

public static <E> ArrayBlockingQueue<E> reduceQueueCapacity(ArrayBlockingQueue<E> oldQueue) {
    int oldCapacity = QueueUtils.getQueueCapacity(oldQueue);
    ArrayBlockingQueue<E> newQueue = new ArrayBlockingQueue<>(oldCapacity - 1);
    // 一次性转移所有元素，线程安全
    oldQueue.drainTo(newQueue);
    return newQueue;
}

当然，这里要注意后续所有操作都要切换到新队列，避免还有线程引用旧队列。

内容的提问来源于stack exchange，提问作者egerardus