How MemorySafeLBQ Prevents OOM in Java Thread Pools: A Deep Dive

The author, Su San, discovered a pull request named MemorySafeLBQ in an open‑source project and decided to investigate how it claims to be memory‑safe.

Traditional thread pools often use FixedThreadPool or SingleThreadPool with an unbounded LinkedBlockingQueue, whose default capacity is Integer.MAX_VALUE, leading to potential OOM when the queue grows.

MemoryLimitedLBQ is a custom queue that extends LinkedBlockingQueue and adds a memoryLimiter object to enforce a memory limit.

Key fields of the limiter include:

memoryLimit – the maximum allowed memory for the queue.

memory – a LongAdder tracking current memory usage.

acquireLock, notLimited, releaseLock, notEmpty – locks for thread‑safe operations.

inst – an Instrumentation instance used to estimate object size.

The put method calls memoryLimiter.acquireInterruptibly, which obtains the object's size via inst.getObjectSize(e) and checks whether adding it would exceed memoryLimit. If so, the thread waits on notLimited.await(); otherwise it updates memory and proceeds.

while (sum + objectSize >= memoryLimit) {
    notLimited.await();
}

A bug existed because the variable sum was a stale snapshot; the fix replaces it with memory.sum() to always read the latest value.

MemorySafeLBQ also extends LinkedBlockingQueue but takes a different approach: it defines a maxFreeMemory (default 256 MB) and checks the JVM's remaining heap using ManagementFactory.getMemoryMXBean(). The core method hasRemainedMemory returns true only if the free memory exceeds maxFreeMemory, and the queue blocks otherwise.

while (memory.sum() + objectSize >= memoryLimit) {
    notLimited.await();
}

Because MemorySafeLBQ does not rely on Instrumentation, it is simpler to use and considered more practical.

Both queues are framework‑agnostic; their source files can be copied into any Java project and used directly.

In summary, MemoryLimitedLBQ limits the memory consumed by the queue itself, while MemorySafeLBQ limits the overall JVM free memory, offering a safer alternative for preventing OOM in high‑throughput thread‑pool scenarios.