public class ByteArrayPool
extends java.lang.Object
byte[] objects. Its purpose is to
supply those buffers to consumers who need to use them for a short period of time and then
dispose of them. Simply creating and disposing such buffers in the conventional manner can
considerable heap churn and garbage collection delays on Android, which lacks good management of
short-lived heap objects. It may be advantageous to trade off some memory in the form of a
permanently allocated pool of buffers in order to gain heap performance improvements; that is
what this class does.
A good candidate user for this class is something like an I/O system that uses large temporary
byte[] buffers to copy data around. In these use cases, often the consumer wants
the buffer to be a certain minimum size to ensure good performance (e.g. when copying data chunks
off of a stream), but doesn't mind if the buffer is larger than the minimum. Taking this into
account and also to maximize the odds of being able to reuse a recycled buffer, this class is
free to return buffers larger than the requested size. The caller needs to be able to gracefully
deal with getting buffers any size over the minimum.
If there is not a suitably-sized buffer in its recycling pool when a buffer is requested, this class will allocate a new buffer and return it.
This class has no special ownership of buffers it creates; the caller is free to take a buffer it receives from this pool, use it permanently, and never return it to the pool; additionally, it is not harmful to return to this pool a buffer that was allocated elsewhere, provided there are no other lingering references to it.
This class ensures that the total size of the buffers in its recycling pool never exceeds a certain byte limit. When a buffer is returned that would cause the pool to exceed the limit, least-recently-used buffers are disposed.
| Modifier and Type | Field and Description |
|---|---|
protected static java.util.Comparator<byte[]> |
BUF_COMPARATOR
Compares buffers by size
|
| Constructor and Description |
|---|
ByteArrayPool(int sizeLimit) |
| Modifier and Type | Method and Description |
|---|---|
byte[] |
getBuf(int len)
Returns a buffer from the pool if one is available in the requested size, or allocates a new
one if a pooled one is not available.
|
void |
returnBuf(byte[] buf)
Returns a buffer to the pool, throwing away old buffers if the pool would exceed its allotted
size.
|
protected static final java.util.Comparator<byte[]> BUF_COMPARATOR
public ByteArrayPool(int sizeLimit)
sizeLimit - the maximum size of the pool, in bytespublic byte[] getBuf(int len)
len - the minimum size, in bytes, of the requested buffer. The returned buffer may be
larger.public void returnBuf(byte[] buf)
buf - the buffer to return to the pool.