netty5学习笔记-内存池3-PoolChunkList

转自：https://blog.csdn.net/youaremoon/article/details/48085591 

前面我们介绍了PoolChunk以及针对page的更细粒度的PoolSubpage，其实在chunk的上层还有一个管理类：PoolChunkList，PoolChunkList负责管理多个chunk的生命周期，在此基础上对内存分配进行进一步的优化，那它是如何去做的呢？我们来简单的了解下，先看看它的几个属性：

[java]  view plain  copy

1. PoolArena<T> arena; // 这个东西又出现了，看来是个终极boss啊，后面再提  
2. // 没有list还有自己的next和prev节点，最终组成一个list的link list  
3. PoolChunkList<T> nextList;  
4. PoolChunkList<T> prevList;  
5.   
6. // chunk有prev和next两个属性，因此这里只用一个节点就可以维护一个chunk链  
7. PoolChunk<T> head;  
8. // 当前list中的chunk最小使用比例  
9. int minUsage;   
10. // 当前list中的chunk最大使用比例  
11. int maxUsage;   

        上面第二行第三行出现了nextList,prevList，可以想到在netty内存分配(其实并不是netty发明的，这里只是代称，不要太纠结）里，除了chunk是被一个list管理的，连list本身也组成了一个更大的list。 为什么这么做了，先不急，我们先简单的看下PoolChunkList中的方法：

[java]  view plain  copy

1.        // 为buf分配指定大小的内存  
2.    boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {  
3. // 如果list中没有chunk则直接返回，看来这个list本身没有创建chunk的能力啊，只是负责维护chunk链。  
4.        // PoolChunkList旁白：我不是内存的创建者，只是内存的搬运工  
5.        if (head == null) {  
6.            return false;  
7.        }  
8.   
9. // 我们一个一个chunk开始找  
10.        for (PoolChunk<T> cur = head;;) {  
11.            long handle = cur.allocate(normCapacity);  
12.            if (handle < 0) {  
13.     // handle < 0表示分配失败，继续到下一个chunk尝试  
14.                cur = cur.next;  
15.                if (cur == null) {  
16.                    return false;  
17.                }  
18.            } else {  
19.     // 分配成功则将分配到的资源赋给ByteBuf  
20.                cur.initBuf(buf, handle, reqCapacity);  
21.     // 当前chunk的使用量超过一个上限阈值，则将其从当前list转移到下一个list  
22.                if (cur.usage() >= maxUsage) {  
23.                    remove(cur);  
24.                    nextList.add(cur);  
25.                }  
26.                return true;  
27.            }  
28.        }  
29.    }  

        这段代码有一处比较重要，当一个chunk的用量超过一定的比例，会将该chunk从当前list挪到下一个list中，这样挪有什么好处呢？ 我们知道chunk本身是从连续的内存中分配一小段连续的内存，这样实际使用内存者读写很方便，然而这种策略也带来了一个坏处，随着内存的不断分配和回收，chunk中可能存在很多碎片。 碎片越来越多后我们想分配一段连续内存的失败几率就会提高。针对这种情况我们可以把使用比例较大的chunk放到更后面，而先从使用比例更小的chunk中更早，这样成功的几率就提高了。然而光把chunk往后放是不科学的，因为随着内存的释放，原先被严重瓜分的chunk中会存在越来越多的大块连续内存，所以还得在特定条件下把chunk从后往前调。调整的时机当然就是在内存释放的时候了：

[java]  view plain  copy

1.    // 释放指定chunk内的指定page或page内的subpage  
2.    void free(PoolChunk<T> chunk, long handle) {  
3.        // handle代表了chunk中的某个page  
4.        chunk.free(handle);  
5. // 用量少于阈值则从当前list移到前一个list,如果不存在前一个list,则销毁chunk  
6.        if (chunk.usage() < minUsage) {  
7.            remove(chunk);  
8.            if (prevList == null) {  
9.                // 从这里我们可以看出在一个chunk经历了一些列的分配内存、释放内存之后，list会将整个chunk释放掉  
10.                // 这样如果在流量高峰期分配了较多内存，随着流量的慢慢回落，内存会慢慢的释放出来。  
11.                assert chunk.usage() == 0;  
12.                arena.destroyChunk(chunk);  
13.            } else {  
14.                prevList.add(chunk);  
15.            }  
16.        }  
17.    }  

        上面的代码可以看到，一个chunk最终是会被释放的，但释放的条件是当前chunk已经没有内存被使用了，所以我们必须保证在这个可以释放的PoolChunkList的minUsage=0，否则就会出现在使用中的chunk被回收的状况。

        看完上面两个方法，我们会发现一个chunk的生命周期并不是在一个固定的list中的，随着内存的分配和释放，他也会进入到不同的list中去。这样我们就必须得注意，两个相邻的PoolChunkList,前一个list的maxUsage和后一个list的minUsage的值必须得有一段交叉得值来缓冲，否则会出现某个usage在临界值的chunk不停的在两个list之间来回移动。比如前一个list是【0,50】则后一个list可以是【25-75】而不能是【50-75】。同时也要注意尾节点上的maxUsage一定要等于100，这样chunk占满后才不会被继续往后挪（后面也没有可用list了）。

       从前面的allocate方法可以看出，PoolChunkList本身没有chunk的创建，因此还需要给外部开放一个添加chunk的方法：

[java]  view plain  copy

1. // 增加节点  
2.    void add(PoolChunk<T> chunk) {  
3. // 如果超过当前list的上限阈值，则放入下一个list  
4.        if (chunk.usage() >= maxUsage) {  
5.            nextList.add(chunk);  
6.            return;  
7.        }  
8.   
9.        chunk.parent = this;  
10.        if (head == null) {  
11.     //  不存在头结点则该节点作为头结点  
12.            head = chunk;  
13.            chunk.prev = null;  
14.            chunk.next = null;  
15.        } else {  
16.     // 存在头结点则将该节点放到头结点之前，该节点成为头结点。  
17.     // 刚放入的节点使用比例相对更小，分配到资源的可能性更大，因此放到头结点  
18.            chunk.prev = null;  
19.            chunk.next = head;  
20.            head.prev = chunk;  
21.            head = chunk;  
22.        }  
23.    }  

         移除方法(remove)比较简单就是从list中去掉该chunk，并改变相邻节点的指向，这里就不贴代码了。一个chunk被移除后有三种可能的去向：

1、由于使用量增大被添加到后面的list中；

2、由于使用量减小被添加到前面的list中；

3、由于所有内存被释放而直接被释放(destroy)。

        先小小的总结下，PoolChunkList主要是为了提高内存分配的效率，每个list中包含多个chunk，而多个list又可以形成一个大的link list，在进行内存分配时，我们可以先从比较靠前的list中分配内存，这样分配到的几率更大。在高峰期申请过多的内存后，随着流量下降慢慢的释放掉多余内存，形成一个良性的循环。需要注意的时由于需要对无用的chunk进行释放，PoolChunkList形成的link list并不是一个完整的双向链表，而是一个包含出口的链表（这里说法可能不够准确，意思就是这个双向链表中的其中一个分头结点的节点只有一个next节点没有prev节点。

        最后我们看看加入list后的样子：