PooledByteBuf分配及回收之六PooledUnsafeDirectByteBuf初始化

PooledByteBufAllocator初始化

PoolThreadCache初始化

PoolAerna初始化

PoolChunk初始化

PoolSubpage初始化

PooledUnsafeDirectByteBuf初始化

分配微小型PooledByteBuf（未命中缓存场景）

分配小型PooledByteBuf（未命中缓存场景）

分配普通型PooledByteBuf（未命中缓存场景）

PoolChunkList源码解析

ReferenceCountUpdater源码解析

Recycler及基内部类初始化

Recycler.Stack＜T＞ 压入对象

Recycler.Stack＜T＞ 弹出对象

PooledByteBuf的回收

 

final class PooledUnsafeDirectByteBuf extends PooledByteBuf<ByteBuffer>

PooledByteBuf的属性

属性	含义	值
private final Handle<PooledByteBuf<T>> recyclerHandle	回收处理句柄 这里的T是ByteBuffer
protected PoolChunk<T> chunk	通过哪个chunk分配的
protected long handle
protected T memory	内存 这里的T是ByteBuffer
protected int offset	偏移量
protected int length	长度
int maxLength	最大长度
PoolThreadCache cache	通过哪个PoolThreadCache分配的
ByteBuffer tmpNioBuf
private ByteBufAllocator allocator	通过哪个分配器分配的

 

构造方法

PooledByteBuf的构造方法

    protected PooledByteBuf(Handle<? extends PooledByteBuf<T>> recyclerHandle, int maxCapacity) {
        super(maxCapacity);
        this.recyclerHandle = (Handle<PooledByteBuf<T>>) recyclerHandle;
    }

PooledUnsafeDirectByteBuf的构造方法

    private PooledUnsafeDirectByteBuf(Handle<PooledUnsafeDirectByteBuf> recyclerHandle, int maxCapacity) {
        super(recyclerHandle, maxCapacity);
    }

PooledUnsafeDirectByteBuf的初始化是通过newInstance的静态方法完成的

    static PooledUnsafeDirectByteBuf newInstance(int maxCapacity) {
        PooledUnsafeDirectByteBuf buf = RECYCLER.get();
        buf.reuse(maxCapacity);
        return buf;
    }

其中的RECYCLER是个静态属性

    private static final ObjectPool<PooledUnsafeDirectByteBuf> RECYCLER = ObjectPool.newPool(
            new ObjectCreator<PooledUnsafeDirectByteBuf>() {
        @Override
        public PooledUnsafeDirectByteBuf newObject(Handle<PooledUnsafeDirectByteBuf> handle) {
            return new PooledUnsafeDirectByteBuf(handle, 0);
        }
    });

这里涉及的对象池的概念,概括来说通过对象池获取一个对象的流程如下:

对象池原理初探

ObjectCreator<T>接口定义

    public interface ObjectCreator<T> {

        /**
         * Creates an returns a new {@link Object} that can be used and later recycled via
         * {@link Handle#recycle(Object)}.
         */
        T newObject(Handle<T> handle);
    }

如下图是它的一个匿名实现

ObjectPool<T>抽象类定义

    ObjectPool() { }

    public abstract T get();

    public static <T> ObjectPool<T> newPool(final ObjectCreator<T> creator) {
        return new RecyclerObjectPool<T>(ObjectUtil.checkNotNull(creator, "creator"));
    }

ObjectPool<T>的私有静态内部类RecyclerObjectPool<T>定义

    private static final class RecyclerObjectPool<T> extends ObjectPool<T> {
        private final Recycler<T> recycler;

        RecyclerObjectPool(final ObjectCreator<T> creator) {
             recycler = new Recycler<T>() {
                @Override
                protected T newObject(Handle<T> handle) {
                    return creator.newObject(handle);
                }
            };
        }

        @Override
        public T get() {
            return recycler.get();
        }
    }

RecyclerObjectPool<T>使用的Recycler<T>较关键的定义

    public final T get() {
        if (maxCapacityPerThread == 0) {
            return newObject((Handle<T>) NOOP_HANDLE);
        }
        Stack<T> stack = threadLocal.get();
        DefaultHandle<T> handle = stack.pop();
        if (handle == null) {
            handle = stack.newHandle();
            handle.value = newObject(handle);
        }
        return (T) handle.value;
    }

    protected abstract T newObject(Handle<T> handle);

         //Stack中newHandle的实现
         DefaultHandle<T> newHandle() {
            return new DefaultHandle<T>(this);
        }

DefaultHandle<T>的定义 

   private static final class DefaultHandle<T> implements Handle<T> {
        int lastRecycledId;
        int recycleId;

        boolean hasBeenRecycled;

        Stack<?> stack;
        Object value;

        DefaultHandle(Stack<?> stack) {
            this.stack = stack;
        }

        @Override
        public void recycle(Object object) {
            if (object != value) {
                throw new IllegalArgumentException("object does not belong to handle");
            }

            Stack<?> stack = this.stack;
            if (lastRecycledId != recycleId || stack == null) {
                throw new IllegalStateException("recycled already");
            }

            stack.push(this);
        }
    }

 

那么对象池获取一个对象的流程是这样的:

1. ObjectPool<T>.get()  实际上也就是 RecyclerObjectPool<T>.get()
2. RecyclerObjectPool<T>.get() 中直接调用了Recycler<T>.get()
3. Recycler<T>.get()中实现如下
   从Stack<T>中pop（弹出）一个对象,如果不存在则创建一个DefaultHandle<T>  handle 那么这里就明确Stack中存储的是DefaultHandle<T>   
   设置handle.value = newObject(handle)  而newObject(handle)的具体实现是 ObjectCreator.newObject(handle)
   而ObjectCreator.newObject(handle)的具体实现是  new PooledUnsafeDirectByteBuf(handle, 0);
   所以DefaultHandle<T>  handle.value指向了一个PooledUnsafeDirectByteBuf,Stack存储DefaultHandle时也相当于存储了PooledUnsafeDirectByteBuf
   而PooledUnsafeDirectByteBuf的hanle指向了一个DefaultHandle