自顶向下深入分析Netty(十)--PoolChunkList

JEMalloc分配算法文中介绍过,Chunk块随着内存使用率的变化,有六种状态:QINIT,Q0,Q25,Q50,Q75,Q100。可知,一种状态可能有多个Chunk块,Netty使用PoolChunkList来存储这些Chunk块,它们之间的关系如下图所示:

Chunk与PoolChunkList

有六种状态所以有六个PoolChunkList,它们之间除了QINIT外形成双向链表;PoolChunkList中的Chunk块也形成双向链表,其中头结点是双向链表的尾部,且新加入的节点也加到尾部。以Q25依次加入Chunk1,Chunk2,Chunk3为例,形成的链表如图,其中Head节点是最后加入的Chunk3节点。Chunk随着内存使用率的变化,会在PoolChunkList中移动,初始时都在QINI,随着使用率增大,移动到Q0,Q25等;随着使用率降低,又移回Q0,当Q0中的Chunk块不再使用时,从Q0中移除。Netty对各状态内存使用率的定义稍有不同,见下表:

状态 最小内存使用率 最大内存使用率
QINIT 1 25
Q0 1 50
Q25 25 75
Q50 50 100
Q75 75 100
Q100 100 100

明白了这些,再来分析源码实现。首先看成员变量:

    private final PoolArena<T> arena; // 所属的Arena
    private final int minUsage; // 状态的最小内存使用率
    private final int maxUsage; // 状态的最大内存使用率
    private final int maxCapacity; // 该状态下的一个Chunk可分配的最大字节数

    private PoolChunk<T> head; // head节点
    private final PoolChunkList<T> nextList; // 下一个状态
    private PoolChunkList<T> prevList; // 上一个状态

构造方法如下:

    PoolChunkList(PoolArena<T> arena, PoolChunkList<T> nextList, 
                int minUsage, int maxUsage, int chunkSize) {
        this.arena = arena;
        this.nextList = nextList;
        this.minUsage = minUsage;
        this.maxUsage = maxUsage;
        // 计算该状态下,一个Chunk块可以分配的最大内存
        maxCapacity = calculateMaxCapacity(minUsage, chunkSize);
    }
    
     private static int calculateMaxCapacity(int minUsage, int chunkSize) {
        minUsage = minUsage0(minUsage);

        if (minUsage == 100) {
            return 0;   // Q100 不能再分配
        }
        // Q25中一个Chunk可以分配的最大内存为0.75 * ChunkSize
        return  (int) (chunkSize * (100L - minUsage) / 100L);
    }

形成状态PoolChunkList的双向链表代码在PoolArena中,再次列出如下:

    q100 = new PoolChunkList<T>(this, null, 100, Integer.MAX_VALUE, chunkSize);
    q075 = new PoolChunkList<T>(this, q100, 75, 100, chunkSize);
    q050 = new PoolChunkList<T>(this, q075, 50, 100, chunkSize);
    q025 = new PoolChunkList<T>(this, q050, 25, 75, chunkSize);
    q000 = new PoolChunkList<T>(this, q025, 1, 50, chunkSize);
    qInit = new PoolChunkList<T>(this, q000, Integer.MIN_VALUE, 25, chunkSize);

    q100.prevList(q075);
    q075.prevList(q050);
    q050.prevList(q025);
    q025.prevList(q000);
    q000.prevList(null);
    qInit.prevList(qInit);

其中的prevList()方法如下:

    void prevList(PoolChunkList<T> prevList) {
        assert this.prevList == null; // 这个方法只应该在创建时调用一次
        this.prevList = prevList;
    }

接着分析,在PoolChunkList中的PoolChunk形成的双向链表的操作,代码如下:

    // 增加一个Chunk节点
    void add0(PoolChunk<T> chunk) {
        chunk.parent = this;
        if (head == null) {
            head = chunk;
            chunk.prev = null;
            chunk.next = null;
        } else {
            chunk.prev = null;
            chunk.next = head;
            head.prev = chunk;
            head = chunk;
        }
    }

    // 删除一个Chunk节点
    private void remove(PoolChunk<T> cur) {
        if (cur == head) {
            head = cur.next;
            if (head != null) {
                head.prev = null;
            }
        } else {
            PoolChunk<T> next = cur.next;
            cur.prev.next = next;
            if (next != null) {
                next.prev = cur.prev;
            }
        }
    }

将一个PoolChunk加入到PoolChunkList中的代码如下:

    void add(PoolChunk<T> chunk) {
        if (chunk.usage() >= maxUsage) {
            nextList.add(chunk);
            return;
        }
        add0(chunk);
    }

注意该方法实质是一个递归调用,在if语句中会找到真正符合状态的PoolChunkList,然后才执行add0()加入PoolChunk节点。随着内存使用率的增加,需要调用add()方法将PoolChunk向右移动到正确状态的PoolChunkList;同理,随着内存使用率的减小,也需要一个方法将PoolChunk向左移动到正确状态。在实现中,这个方法为move(),名字带有歧义,忽略名字,代码如下:

    private boolean move(PoolChunk<T> chunk) {
        assert chunk.usage() < maxUsage;

        if (chunk.usage() < minUsage) {
            return move0(chunk); // 向左移动到正确状态,递归调用
        }

        add0(chunk); // 到达正确状态后,加入双向链表
        return true;
    }

    private boolean move0(PoolChunk<T> chunk) {
        if (prevList == null) {
            // 此时表示chunk为Q0状态,且还需要移动,说明Chunk使用率为0
            assert chunk.usage() == 0;
            return false;
        }
        return prevList.move(chunk); // 向左移动
    }

接下来,分析关键的分配过程,代码如下:

    boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {
        // 该状态下还没有符合的Chunk块
        // 申请的内存已超过一个Chunk块可以分配的最大内存
        if (head == null || normCapacity > maxCapacity) {
            return false;
        }

        // Chunk链表中寻找满足需求的Chunk块
        for (PoolChunk<T> cur = head;;) {
            long handle = cur.allocate(normCapacity);
            if (handle < 0) {
                cur = cur.next;
                if (cur == null) {
                    return false; // 没有满足需求
                }
            } else {
                // 满足需求,在该Chunk块中分配
                cur.initBuf(buf, handle, reqCapacity);
                if (cur.usage() >= maxUsage) {
                    remove(cur);    
                    nextList.add(cur); // 分配后需要向右移动至符合的状态
                }
                return true;
            }
        }
    }

分配过程简单明了,释放过程也如此,代码如下:

    boolean free(PoolChunk<T> chunk, long handle) {
        chunk.free(handle); // chunk释放占用的内存
        if (chunk.usage() < minUsage) {
            remove(chunk);
            return move0(chunk); // 向左移动到符合的状态
        }
        return true;
    }

最后,销毁PoolChunkList的方法如下:

    void destroy(PoolArena<T> arena) {
        PoolChunk<T> chunk = head;
        while (chunk != null) {
            arena.destroyChunk(chunk);  // 释放Chunk
            chunk = chunk.next;
        }
        head = null; // GC回收节点
    }

依次将Chunk中的内存销毁,然后由GC回收链表节点。至此,PoolChunkList分析完毕。
相关链接:

  1. JEMalloc分配算法
  2. PoolArena
  3. PoolChunk
  4. PoolSubpage
  5. PooThreadCache
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,829评论 1 331
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,603评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,846评论 0 226
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,600评论 0 191
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,780评论 3 272
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,695评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,136评论 2 293
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,862评论 0 182
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,453评论 0 229
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,942评论 2 233
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,347评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,790评论 2 236
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,293评论 3 221
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,839评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,448评论 0 181
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,564评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,623评论 2 249

推荐阅读更多精彩内容