netty内存池之poolSubpage

最新推荐文章于 2025-06-23 23:12:45 发布

原创最新推荐文章于 2025-06-23 23:12:45 发布 · 632 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#netty #内存池 #pool #Subpage

源码学习同时被 2 个专栏收录

45 篇文章

订阅专栏

Netty

9 篇文章

订阅专栏

本文深入探讨了Netty内存池中PoolSubpage的作用，解释了它如何管理和分配小于8k的内存，避免资源浪费。内容包括PoolChunk、element、bitmap的工作原理，以及分配和释放内存的详细过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

PoolChunk负责内存的分配与释放，其内部最小的分配单元为page，page的默认大小为8k。如果我们申请很多小块内存时，都按照page来分配，那么资源浪费可不是一点半点。针对这个问题，netty将page拆成了更小的内存块element，但超出了PoolChunk的负责范围，此时netty使用PoolSubpage来解决这个问题。

PoolSubpage(PoolSubpage<T> head, PoolChunk<T> chunk, int memoryMapIdx, int runOffset, int pageSize, int elemSize) {
        this.chunk = chunk;
        this.memoryMapIdx = memoryMapIdx;
        this.runOffset = runOffset;
        this.pageSize = pageSize;
        bitmap = new long[pageSize >>> 10]; // pageSize / 16 / 64
        init(head, elemSize);
    }

无非是赋值，我们来看下bitmap数组大小为什么是pageSize>>10;从注释中可以看出，16B是elementSize最小值，64是long的位数，也就是说用bitmap的位个数可以满足分配最多element时的数目。bitmap大小为什么不使用pageSize/elemenSize/64？因为申请最大空间后，对于后面可回收后重新分配该对象，不需要重新开辟空间，只需重新调用init()赋值。

head是之前调用arena.findSubpagePoolHead(normCapacity)的返回值。可以从函数调用中分析出，该方法要不是在构造函数中调用，或者在subpage回收后重新分配时调用。

void init(PoolSubpage<T> head, int elemSize) {
        doNotDestroy = true;
        this.elemSize = elemSize;
        if (elemSize != 0) {
            maxNumElems = numAvail = pageSize / elemSize;
            nextAvail = 0;
            bitmapLength = maxNumElems >>> 6;
            if ((maxNumElems & 63) != 0) {
                bitmapLength ++;
            }

            for (int i = 0; i < bitmapLength; i ++) {
                bitmap[i] = 0;
            }
        }
        addToPool(head);
    }

先把标志位doNoDestroy设为true，表示该page在使用中，不能被清除。然后赋值。计算出实际使用的bitmapLength大小。并把标志位清零(因为之前可能用过有垃圾数据，仅需把当前要用的部分清零)。

chunk在分配空间时，大小8k以下的空间交给subPage管理，然而chunk并为将subPage暴露给外面，于是subPage通过addToPool()方法，将自己加入到chunk.arean的pool中。

    private void addToPool(PoolSubpage<T> head) {
        assert prev == null && next == null;
        prev = head;
        next = head.next;
        next.prev = this;
        head.next = this;
    }

仅仅是链表插入操作，将当前节点插入到head之后。

回到chunk中分配小于8k以下部分的方法中

 int subpageIdx = subpageIdx(id);
            PoolSubpage<T> subpage = subpages[subpageIdx];
            if (subpage == null) {
                subpage = new PoolSubpage<T>(head, this, id, runOffset(id), pageSize, normCapacity);
                subpages[subpageIdx] = subpage;
            } else {
                subpage.init(head, normCapacity);
            }
            return subpage.allocate();

我们来看下subpage.allocate()；

 long allocate() {
        if (elemSize == 0) {
            return toHandle(0);
        }

        if (numAvail == 0 || !doNotDestroy) {
            return -1;
        }

        final int bitmapIdx = getNextAvail();
        int q = bitmapIdx >>> 6;
        int r = bitmapIdx & 63;
        assert (bitmap[q] >>> r & 1) == 0;
        bitmap[q] |= 1L << r;

        if (-- numAvail == 0) {
            removeFromPool();
        }

        return toHandle(bitmapIdx);
    }

如果此时没有可分配的element，那么直接返回。getNetxAvail()无非找到当前page中可分配的段的下标，然后在bitmap上标记该段被使用。如果该page所有可用element分配完了后，将这个subpage从pool中删除。

我们可以看到这里在subPage这个数据结构上进行“管理分配”，返回一个element的index。toHandle操作无非在返回的long上标记可用空间。

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

一个long，其中低32位用来表示memoryMapIdx，无非是执行分配的具体page，高32位中的低6位表示bitmap，即定位到当前page中可分配的段。

我们来看下getNextAvail方法。

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

直接从成员中取出下一个可用的位置，如果nextAvail>=0，要么是刚初始化，或者是有element重新回收未分配的，直接返回，并把其标记为-1，否则继续调用findNextAvail。

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

没有明确指定nextAvail位置时，于是从头到尾查。先定位到bitmaps中的哪个long没有分配完。

private int findNextAvail0(int i, long bits) {
        final int maxNumElems = this.maxNumElems;
        final int baseVal = i << 6;

        for (int j = 0; j < 64; j ++) {
            if ((bits & 1) == 0) {
                int val = baseVal | j;
                if (val < maxNumElems) {
                    return val;
                } else {
                    break;
                }
            }
            bits >>>= 1;
        }
        return -1;
    }

于是找那个long上的哪个位未分配，于是构造val返回。val就是最低6位表示该long上的哪个字节，其他位即val >> 6后记录的是哪个long，即bitmap的下标。其实val就是bitmapIdx，它定位到具体的某个element。

关于上一篇遗留问题，总结一下。

poolChunk的allocate函数返回一个long类型的handle，其中当handle<Integer.MAX_VALUE时，它表示chunk的节点id，当handle>Integer.MAX_VALUE，他分配的是一个Subpage,节点id=memoryMapIdx, 且能得到Subpage的bitmapIdx。

再来看下poolChunk对应的小于8k的free过程。

        int bitmapIdx = bitmapIdx(handle);

        if (bitmapIdx != 0) { // free a subpage
            PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
            assert subpage != null && subpage.doNotDestroy;

            // Obtain the head of the PoolSubPage pool that is owned by the PoolArena and synchronize on it.
            // This is need as we may add it back and so alter the linked-list structure.
            PoolSubpage<T> head = arena.findSubpagePoolHead(subpage.elemSize);
            synchronized (head) {
                if (subpage.free(head, bitmapIdx & 0x3FFFFFFF)) {
                    return;
                }
            }
        }

先根据handle取到bitmapIdx，再取出对应的subpage，找到根据elemSize取出head，加锁(应为涉及到head为头的链表的改变)，再调用subpage.free。

boolean free(PoolSubpage<T> head, int bitmapIdx) {
        if (elemSize == 0) {
            return true;
        }
        int q = bitmapIdx >>> 6;
        int r = bitmapIdx & 63;
        assert (bitmap[q] >>> r & 1) != 0;
        bitmap[q] ^= 1L << r;

        setNextAvail(bitmapIdx);

        if (numAvail ++ == 0) {
            addToPool(head);
            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;
        }
    }

无非在bitmap上标记为1可用，然后将当前bitmapIdx设置到nextAvail，如果当前subpage的可用大小为0，那么把可用大小加1，并且添加到pool中，即head为头的双向链表中。如果添加后numAvail==maxNumElems说明该page上所有element都未分配。如果该subpage是链上的唯一一块那么不处理(这样做尽可能的保证arena分配小内存时能直接从pool中取，而不用再到chunk中去获取)，否则将其从arean的pool的链表中剔除。

连着写了两篇，netty内存池的结构越来越清晰了，当然问题还有不少，比如分配大小大于一整个chunk后如何处理，subpage的elemSize存在很多可能值，handle具体用处。一步步探索吧。