static PooledHeapByteBuf newInstance(int maxCapacity) {
        PooledHeapByteBuf buf = RECYCLER.get();
        buf.setRefCnt(1);
        buf.maxCapacity(maxCapacity);
        return buf;
    }

private void allocate(PoolThreadCache cache, PooledByteBuf<T> buf, final int reqCapacity) {
        final int normCapacity = normalizeCapacity(reqCapacity); //@1
        if (isTinyOrSmall(normCapacity)) { // capacity < pageSize //@2
            int tableIdx;
            PoolSubpage<T>[] table;
            if (isTiny(normCapacity)) { // < 512 //@21
                if (cache.allocateTiny(this, buf, reqCapacity, normCapacity)) {//@211
                    // was able to allocate out of the cache so move on
                    return;
                }
                tableIdx = tinyIdx(normCapacity);
                table = tinySubpagePools;
            } else { //@22
                if (cache.allocateSmall(this, buf, reqCapacity, normCapacity)) {
                     //@221
                    // was able to allocate out of the cache so move on
                    return;
                }
                tableIdx = smallIdx(normCapacity);
                table = smallSubpagePools;
            }
            synchronized (this) { //@3
                final PoolSubpage<T> head = table[tableIdx];
                final PoolSubpage<T> s = head.next;
                if (s != head) {
                    assert s.doNotDestroy && s.elemSize == normCapacity;
                    long handle = s.allocate();
                    assert handle >= 0;
                    s.chunk.initBufWithSubpage(buf, handle, reqCapacity);
                    return;
                }
            }
        } else if (normCapacity <= chunkSize) { // @4
            if (cache.allocateNormal(this, buf, reqCapacity, normCapacity)) {
                // was able to allocate out of the cache so move on
                return;
            }
        } else { //@5
            // Huge allocations are never served via the cache so just call allocate // Huge
            allocateHuge(buf, reqCapacity);
            return;
        }
        allocateNormal(buf, reqCapacity, normCapacity); //@6
    }
 

private synchronized void allocateNormal(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {
        if ( q050.allocate(buf, reqCapacity, normCapacity)
              || q025.allocate(buf, reqCapacity, normCapacity)
              || q000.allocate(buf, reqCapacity, normCapacity)
              || qInit.allocate(buf, reqCapacity, normCapacity)
              || q075.allocate(buf, reqCapacity, normCapacity)
              || q100.allocate(buf, reqCapacity, normCapacity)) {
            return;
        } // @1
        // Add a new chunk.
        PoolChunk<T> c = newChunk(pageSize, maxOrder, pageShifts, chunkSiz e); //@2
        long handle = c.allocate(normCapacity); //@3
        assert handle > 0;
        c.initBuf(buf, handle, reqCapacity); //@4
        qInit.add(c); //@5
    }

long allocate(int normCapacity) {
        if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize
            return allocateRun(normCapacity); //@2
        } else {
            return allocateSubpage(normCapacity); //@1
        }
    }

/**
     * Create/ initialize a new PoolSubpage of normCapacity
     * Any PoolSubpage created/ initialized here is added to subpage pool in the PoolArena that owns this PoolChunk
     *
     * @param normCapacity normalized capacity
     * @return index in memoryMap
     */
    private long allocateSubpage(int normCapacity) {
        int d = maxOrder; // subpages are only be allocated from pages i.e., leaves
        int id = allocateNode(d); //@1
        if (id < 0) {
            return id;
        }
        final PoolSubpage<T>[] subpages = this.subpages;
        final int pageSize = this.pageSize;
        freeBytes -= pageSize;
        int subpageIdx = subpageIdx(id); // @2
        PoolSubpage<T> subpage = subpages[subpageIdx];
        if (subpage == null) {
            subpage = new PoolSubpage<T>(this, id, runOffset(id), pageSize, normCapacity); // 程式碼@3
            subpages[subpageIdx] = subpage;
        } else { //@4
            subpage.init(normCapacity);
        }
        return subpage.allocate(); //程式碼@5
    }

private int allocateNode(int d) {
        int id = 1;
        int initial = - (1 << d); // has last d bits = 0 and rest all = 1
        byte val = value(id);
        if (val > d) { // unusable
            return -1;
        }
        while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0 //@1 
            id <<= 1; //@2
            val = value(id); //@3
            if (val > d) { //@4
                id ^= 1;
                val = value(id);
            }
        }
        byte value = value(id);
        assert value == d && (id & initial) == 1 << d : String.format("val = %d, id & initial = %d, d = %d",
                value, id & initial, d);
        setValue(id, unusable); // mark as unusable //@5
        updateParentsAlloc(id); //@6
        return id;
    }
private byte value(int id) {
        return memoryMap[id];
}

private void updateParentsAlloc(int id) {
        while (id > 1) {// @1
            int parentId = id >>> 1; // @2
            byte val1 = value(id); //@3
            byte val2 = value(id ^ 1); //@4
            byte val = val1 < val2 ? val1 : val2; //@5
            setValue(parentId, val);
            id = parentId;
        }
    }

private int subpageIdx(int memoryMapIdx) {
         return memoryMapIdx ^ maxSubpageAllocs; // remove highest set bit, to get offset
         //我們一般簡單的實現：
         //return memoryMapIdx - maxSubpageAllocs;
        //或 return memoryMapIdx & ( ~( (1 << maxOrder) -1) );
}

/**
     * Returns the bitmap index of the subpage allocation.
     */
    long allocate() {
        if (elemSize == 0) {
            return toHandle(0);
        }
        if (numAvail == 0 || !doNotDestroy) { //@1
            return -1;
        }
        final int bitmapIdx = getNextAvail(); //@2
        int q = bitmapIdx >>> 6; //@3
        int r = bitmapIdx & 63; //@4
        assert (bitmap[q] >>> r & 1) == 0;
        bitmap[q] |= 1L << r; //@5
        if (-- numAvail == 0) {
            removeFromPool(); //@6
        }
        return toHandle(bitmapIdx); //@7
    }

private int getNextAvail() {
        int nextAvail = this.nextAvail;
        if (nextAvail >= 0) { //@1
            this.nextAvail = -1;
            return nextAvail;
        }
        return findNextAvail();
    }

 private int findNextAvail() {
        final long[] bitmap = this.bitmap;
        final int bitmapLength = this.bitmapLength;
        for (int i = 0; i < bitmapLength; i ++) { //@2
            long bits = bitmap[i];
            if (~bits != 0) { //@3
                return findNextAvail0(i, bits); //@4
            }
        }
        return -1;
    }

private int findNextAvail0(int i, long bits) {
        final int maxNumElems = this.maxNumElems;
        final int baseVal = i << 6; //@5
        for (int j = 0; j < 64; j ++) { //遍歷，一個long總代表64個PoolSubpage
            if ((bits & 1) == 0) { //@6
                int val = baseVal | j; //@8
                if (val < maxNumElems) {
                    return val;
                } else {
                    break;
                }
            }
            bits >>>= 1; //@7
        }
        return -1;
    }

private long toHandle(int bitmapIdx) {
        return 0xb000000000000000L | (long) bitmapIdx << 32 | memoryMapIdx;
    }

void initBuf(PooledByteBuf<T> buf, long handle, int reqCapacity) {
        int memoryMapIdx = (int) handle;//@1
        int bitmapIdx = (int) (handle >>> Integer.SIZE); //@2
        if (bitmapIdx == 0) {//@3
            byte val = value(memoryMapIdx);
            assert val == unusable : String.valueOf(val);
            buf.init(this, handle, runOffset(memoryMapIdx), reqCapacity, runLength(memoryMapIdx));
        } else {//@4
            initBufWithSubpage(buf, handle, bitmapIdx, reqCapacity);
        }
    }

void init(PoolChunk<T> chunk, long handle, int offset, int length, int maxLength) {
        assert handle >= 0;
        assert chunk != null;
        this.chunk = chunk;
        this.handle = handle;
        memory = chunk.memory;               // @1
        this.offset = offset;                           // @2
        this.length = length;                         // @3
        this.maxLength = maxLength;         // @4
        setIndex(0, 0);                                   //@5
        tmpNioBuf = null;
        initThread = Thread.currentThread();//@6
    }

private void initBufWithSubpage(PooledByteBuf<T> buf, long handle, int bitmapIdx, int reqCapacity) {
        assert bitmapIdx != 0;
        int memoryMapIdx = (int) handle;
        PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
        assert subpage.doNotDestroy;
        assert reqCapacity <= subpage.elemSize;
        buf.init(
            this, handle,
            runOffset(memoryMapIdx) + (bitmapIdx & 0x3FFFFFFF) * subpage.elemSize, reqCapacity, subpage.elemSize);
    }

/**
     * Allocate a run of pages (>=1)
     *
     * @param normCapacity normalized capacity
     * @return index in memoryMap
     */
    private long allocateRun(int normCapacity) {
        int d = maxOrder - (log2(normCapacity) - pageShifts);    //@1
        int id = allocateNode(d);                                                   //@2
        if (id < 0) {
            return id;
        }
        freeBytes -= runLength(id);                                            //@3
        return id;
    }

private int allocateNode(int d) {
        int id = 1;
        int initial = - (1 << d); // has last d bits = 0 and rest all = 1
        byte val = value(id);
        if (val > d) { // unusable
            return -1;
        }
        while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0
            id <<= 1;
            val = value(id);
            if (val > d) {
                id ^= 1;
                val = value(id);
            }
        }
        byte value = value(id);
        assert value == d && (id & initial) == 1 << d : String.format("val = %d, id & initial = %d, d = %d",
                value, id & initial, d);
        setValue(id, unusable); // mark as unusable
        updateParentsAlloc(id);
        return id;
    }

private void allocateHuge(PooledByteBuf<T> buf, int reqCapacity) {
        buf.initUnpooled(newUnpooledChunk(reqCapacity), reqCapacity);
}
PoolArena.HeapArena：
protected PoolChunk<byte[]> newUnpooledChunk(int capacity) {
        return new PoolChunk<byte[]>(this, new byte[capacity], capacity);
}
PoolChunk非池管理的PoolChunk：
/** Creates a special chunk that is not pooled. */
    PoolChunk(PoolArena<T> arena, T memory, int size) {
        unpooled = true;
        this.arena = arena;
        this.memory = memory;
        memoryMap = null;
        depthMap = null;
        subpages = null;
        subpageOverflowMask = 0;
        pageSize = 0;
        pageShifts = 0;
        maxOrder = 0;
        unusable = (byte) (maxOrder + 1);
        chunkSize = size;
        log2ChunkSize = log2(chunkSize);
        maxSubpageAllocs = 0;
    }
大記憶體的PoolChunk,不快取使用，故內部不會再細化為PoolSubpage等資料結構。
void initUnpooled(PoolChunk<T> chunk, int length) {
        assert chunk != null;

        this.chunk = chunk;
        handle = 0;
        memory = chunk.memory;
        offset = 0;
        this.length = maxLength = length;
        setIndex(0, 0);
        tmpNioBuf = null;
        initThread = Thread.currentThread();
    }

public final boolean release(int decrement) {
        if (decrement <= 0) {
            throw new IllegalArgumentException("decrement: " + decrement + " (expected: > 0)");
        }

        for (;;) {
            int refCnt = this.refCnt;
            if (refCnt < decrement) {
                throw new IllegalReferenceCountException(refCnt, -decrement);
            }

            if (refCntUpdater.compareAndSet(this, refCnt, refCnt - decrement)) {
                if (refCnt == decrement) {
                    deallocate();
                    return true;
                }
                return false;
            }
        }
    }

/**
     * Called once {@link #refCnt()} is equals 0.
     */
    protected abstract void deallocate();
3.1 PooledByteBuf deallocate方法詳解
protected final void deallocate() {
        if (handle >= 0) {
            final long handle = this.handle;
            this.handle = -1;    
            memory = null;
            boolean sameThread = initThread == Thread.currentThread(); 
            initThread = null;
            chunk.arena.free(chunk, handle, maxLength, sameThread);         //@1
            recycle();                                                                                        //@2
        }
    }

/**
  *  @param    chunk
  *  @param    handle,記憶體分配，儲存著bitmapIdx,memoryMapIdx      
  *  @param    normaCapacity   申請的記憶體(釋放的記憶體，取值為PooledByteBuf的 maxLenth)
  *  @param    釋放該PooledByteBuf的執行緒釋放時建立該PooledByteBuf的執行緒
  */
void free(PoolChunk<T> chunk, long handle, int normCapacity, boolean sameThreads) {
        if (chunk.unpooled) {          //@1
            destroyChunk(chunk);
        } else {                                 
            if (sameThreads) {     //@2
                PoolThreadCache cache = parent.threadCache.get();
                if (cache.add(this, chunk, handle, normCapacity)) {
                    // cached so not free it.
                    return;
                }
            }

            synchronized (this) {     //@3
                chunk.parent.free(chunk, handle);
            }
        }
    }

PoolArena.HeapArena
protected void destroyChunk(PoolChunk<byte[]> chunk) {
            // Rely on GC.
}
PoolArena.DirectArena:
protected void destroyChunk(PoolChunk<ByteBuffer> chunk) {
            PlatformDependent.freeDirectBuffer(chunk.memory);   //釋放堆外記憶體
}

/**
     * Free a subpage or a run of pages
     * When a subpage is freed from PoolSubpage, it might be added back to subpage pool of the owning PoolArena
     * If the subpage pool in PoolArena has at least one other PoolSubpage of given elemSize, we can
     * completely free the owning Page so it is available for subsequent allocations
     *
     * @param handle handle to free
     */
    void free(long handle) {
        int memoryMapIdx = (int) handle;                        //@1
        int bitmapIdx = (int) (handle >>> Integer.SIZE);  //@2

        if (bitmapIdx != 0) { // free a subpage    //@3
            PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
            assert subpage != null && subpage.doNotDestroy;
            if (subpage.free(bitmapIdx & 0x3FFFFFFF)) {
                return;
            }
        }
        freeBytes += runLength(memoryMapIdx);     //@4
        setValue(memoryMapIdx, depth(memoryMapIdx));  //@5
        updateParentsFree(memoryMapIdx);                        //@6
    }

/**
     * @return {@code true} if this subpage is in use.
     *         {@code false} if this subpage is not used by its chunk and thus it's OK to be released.
     */
    boolean free(int bitmapIdx) {
        if (elemSize == 0) {
            return true;
        }

        int q = bitmapIdx >>> 6;                         //@1
        int r = bitmapIdx & 63;                            //@2
        assert (bitmap[q] >>> r & 1) != 0;
        bitmap[q] ^= 1L << r;                             //@3

        setNextAvail(bitmapIdx);                         //@4

        if (numAvail ++ == 0) {                          //@5 start
            addToPool();
            return true;
        }

        if (numAvail != maxNumElems) {  
            return true;
        } else {
            // Subpage not in use (numAvail == maxNumElems)
            if (prev == next) {
                // Do not remove if this subpage is the only one left in the pool.
                return true;
            }

            // Remove this subpage from the pool if there are other subpages left in the pool.
            doNotDestroy = false;
            removeFromPool();
            return false;
        }   //@5 end
    }

/**
     * Update method used by free
     * This needs to handle the special case when both children are completely free
     * in which case parent be directly allocated on request of size = child-size * 2
     *
     * @param id id
     */
    private void updateParentsFree(int id) {
        int logChild = depth(id) + 1;
        while (id > 1) {
            int parentId = id >>> 1;
            byte val1 = value(id);
            byte val2 = value(id ^ 1);
            logChild -= 1; // in first iteration equals log, subsequently reduce 1 from logChild as we traverse up

            if (val1 == logChild && val2 == logChild) {
                setValue(parentId, (byte) (logChild - 1));
            } else {
                byte val = val1 < val2 ? val1 : val2;
                setValue(parentId, val);
            }

            id = parentId;
        }
    }

@Override
    public final ByteBuf capacity(int newCapacity) {
        ensureAccessible();

        // If the request capacity does not require reallocation, just update the length of the memory.
        if (chunk.unpooled) {                         //@1
            if (newCapacity == length) {
                return this;
            }
        } else {
            if (newCapacity > length) {                      //@2
                if (newCapacity <= maxLength) {
                    length = newCapacity;
                    return this;
                }
            } else if (newCapacity < length) {              //@3
                if (newCapacity > maxLength >>> 1) {
                    if (maxLength <= 512) {
                        if (newCapacity > maxLength - 16) {
                            length = newCapacity;
                            setIndex(Math.min(readerIndex(), newCapacity), Math.min(writerIndex(), newCapacity));
                            return this;
                        }
                    } else { // > 512 (i.e. >= 1024)
                        length = newCapacity;
                        setIndex(Math.min(readerIndex(), newCapacity), Math.min(writerIndex(), newCapacity));
                        return this;
                    }
                }
            } else {
                return this;
            }
        }

        // Reallocation required.
        chunk.arena.reallocate(this, newCapacity, true);      //@4
        return this;
    }

void reallocate(PooledByteBuf<T> buf, int newCapacity, boolean freeOldMemory) {
        if (newCapacity < 0 || newCapacity > buf.maxCapacity()) {
            throw new IllegalArgumentException("newCapacity: " + newCapacity);
        }

        int oldCapacity = buf.length;
        if (oldCapacity == newCapacity) {
            return;
        }

        PoolChunk<T> oldChunk = buf.chunk;
        long oldHandle = buf.handle;
        T oldMemory = buf.memory;
        int oldOffset = buf.offset;
        int oldMaxLength = buf.maxLength;
        int readerIndex = buf.readerIndex();
        int writerIndex = buf.writerIndex();

        allocate(parent.threadCache.get(), buf, newCapacity);    //@1
        if (newCapacity > oldCapacity) {    //@2 start 
            memoryCopy(
                    oldMemory, oldOffset,
                    buf.memory, buf.offset, oldCapacity);
        } else if (newCapacity < oldCapacity) {
            if (readerIndex < newCapacity) {
                if (writerIndex > newCapacity) {
                    writerIndex = newCapacity;
                }
                memoryCopy(
                        oldMemory, oldOffset + readerIndex,
                        buf.memory, buf.offset + readerIndex, writerIndex - readerIndex);
            } else {
                readerIndex = writerIndex = newCapacity;
            }
        } // @2end

        buf.setIndex(readerIndex, writerIndex);

        if (freeOldMemory) {
            free(oldChunk, oldHandle, oldMaxLength, buf.initThread == Thread.currentThread()); //@3
        }
    }

protected void memoryCopy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int length) {
            if (length == 0) {
                return;
            }

            System.arraycopy(src, srcOffset, dst, dstOffset, length);
        }