@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % _factor) == 0); int b = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Bucket> buckets = bucketsFor(buffer.isDirect()); Bucket bucket = buckets.computeIfAbsent(b,_newBucket); bucket.release(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % _factor) == 0); int b = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Bucket> buckets = bucketsFor(buffer.isDirect()); Bucket bucket = buckets.computeIfAbsent(b,_newBucket); bucket.release(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % _factor) == 0); int b = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Bucket> buckets = bucketsFor(buffer.isDirect()); Bucket bucket = buckets.computeIfAbsent(b,bi->new Bucket(b*_factor,_maxQueue)); bucket.release(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % factor) == 0); int bucket = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect()); // Avoid to create a new queue every time, just to be discarded immediately Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers == null) { byteBuffers = new ConcurrentLinkedQueue<>(); Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers); if (existing != null) byteBuffers = existing; } BufferUtil.clear(buffer); byteBuffers.offer(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % factor) == 0); int bucket = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect()); // Avoid to create a new queue every time, just to be discarded immediately Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers == null) { byteBuffers = new ConcurrentLinkedQueue<>(); Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers); if (existing != null) byteBuffers = existing; } BufferUtil.clear(buffer); byteBuffers.offer(buffer); }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; // nothing to do // validate that this buffer is from this pool assert((buffer.capacity() % factor) == 0); int bucket = bucketFor(buffer.capacity()); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(buffer.isDirect()); // Avoid to create a new queue every time, just to be discarded immediately Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers == null) { byteBuffers = new ConcurrentLinkedQueue<>(); Queue<ByteBuffer> existing = buffers.putIfAbsent(bucket, byteBuffers); if (existing != null) byteBuffers = existing; } BufferUtil.clear(buffer); byteBuffers.offer(buffer); }
@Override public ByteBuffer acquire(int size, boolean direct) { int b = bucketFor(size); ConcurrentMap<Integer, Bucket> buffers = bucketsFor(direct); Bucket bucket = buffers.get(b); if (bucket==null) return newByteBuffer(b*_factor, direct); return bucket.acquire(direct); }
@Override public ByteBuffer acquire(int size, boolean direct) { int b = bucketFor(size); ConcurrentMap<Integer, Bucket> buffers = bucketsFor(direct); Bucket bucket = buffers.get(b); if (bucket==null) return newByteBuffer(b*_factor, direct); return bucket.acquire(direct); }
@Override public ByteBuffer acquire(int size, boolean direct) { int b = bucketFor(size); ConcurrentMap<Integer, Bucket> buffers = bucketsFor(direct); Bucket bucket = buffers.get(b); if (bucket==null) return newByteBuffer(b*_factor, direct); return bucket.acquire(direct); }
@Override public ByteBuffer acquire(int size, boolean direct) { int bucket = bucketFor(size); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct); ByteBuffer result = null; Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers != null) result = byteBuffers.poll(); if (result == null) { int capacity = bucket * factor; result = newByteBuffer(capacity, direct); } BufferUtil.clear(result); return result; }
@Override public ByteBuffer acquire(int size, boolean direct) { int bucket = bucketFor(size); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct); ByteBuffer result = null; Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers != null) result = byteBuffers.poll(); if (result == null) { int capacity = bucket * factor; result = direct ? BufferUtil.allocateDirect(capacity) : BufferUtil.allocate(capacity); } BufferUtil.clear(result); return result; }
@Override public ByteBuffer acquire(int size, boolean direct) { int bucket = bucketFor(size); ConcurrentMap<Integer, Queue<ByteBuffer>> buffers = buffersFor(direct); ByteBuffer result = null; Queue<ByteBuffer> byteBuffers = buffers.get(bucket); if (byteBuffers != null) result = byteBuffers.poll(); if (result == null) { int capacity = bucket * factor; result = direct ? BufferUtil.allocateDirect(capacity) : BufferUtil.allocate(capacity); } BufferUtil.clear(result); return result; }