Fork me on GitHub

Netty内存管理

字数统计: 3.5k字   |   阅读时长≈ 17分

测试：当指定的直接内存可分配大小没有超过，那么gc不会回收直接内存，当指定的直接内存分配大小超过，那么会把没有引用指向的直接内存回收

Netty内存管理

写了个大概意思，

我的csdn博客比较详细https://editor.csdn.net/md/?articleId=108318784

PooledByteBufAllocator

这是一个池化的分配器

1
2
3
4

defaultPageSize = 8192 默认页大小是8k，其可以自定义，但是最后都会转为2的n次幂

defaultMaxOrder = 11 最大深度11

伙伴分配算法的示例图

img

netty是一个数组代表 一个完全二叉树 memoryMap

流程是一个完全二叉树

一个节点的两个子节点叫做两个伙伴，只有两个伙伴都没有分配时才能合并，每次分配通过二叉树遍历找到离比指定容量大的最小的那块内存

分配需知

一页大小8K，总大小为16m

那么 可分页数就是2048页

下图文字部分有误，subpages是tiny，small等缓存分配才用到

1598792949830

这里有多个chunklist（qinit，q000,q025,q050,q100），但是为什么要维护这么一个chunklist

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    void add(PoolChunk<T> chunk) {
        if (chunk.usage() >= maxUsage) {
            nextList.add(chunk);
            return;
        }
        add0(chunk);
    }

boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {
        if (head == null || normCapacity > maxCapacity) {
            // 此PoolChunkList为空或请求的容量大于此PoolChunkList中包含的PoolChunkList可处理的容量。
            return false;
        }

        for (PoolChunk<T> cur = head;;) {
            //从头上开始分
            long handle = cur.allocate(normCapacity);
            if (handle < 0) {
                //chunk节点分不了到下一个开始分
                cur = cur.next;
                if (cur == null) {
                    //没有下一个，说明次chunklist暂时不能分配
                    return false;
                }
            } else {
                //如果分配成功
                cur.initBuf(buf, handle, reqCapacity);
                if (cur.usage() >= maxUsage) {
                    remove(cur);//查看使用率，动态维护chunk位置，减少每一个chunk的碎片
                    nextList.add(cur);
                }
                return true;
            }
        }
    }
1m = 1048 576

每一个chunk加到哪个里面是根据 每一个chunk的使用率来决定的，使用率更高，那么就往后排
    qinit maxUsege 25  maxCapcity 1660,9443 
    q000 mixUsege 1  MaxUsege 50  maxCapcity 1660,9443 
    q025 minUsege 25  MaxUsege 75 maxCapcity 1258,2912
    q050 minUsege 50  MaxUsege 100 maxCapcity 838,8608
    q075 minUsege 75  MaxUsege 100 maxCapcity 419,4304
    q100 只有100的才会过来
    
    所以当要存在一个chunk的情况下，为了减少碎片，分配一个空间先从使用率超过50的来分,然后才是使用至少25
    然后使用率最少1 ，然后是qInit，最后75，为什么这么分，只有一个原因，减少碎片
    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)) {
            ++allocationsNormal;
            return;
        }

        // Add a new chunk.
        PoolChunk<T> c = newChunk(pageSize, maxOrder, pageShifts, chunkSize);
        long handle = c.allocate(normCapacity);
        ++allocationsNormal;
        assert handle > 0;
        c.initBuf(buf, handle, reqCapacity);
        qInit.add(c);
    }

分配流程

PoolArea

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

tiny 16 32 48 64 80 96 ... 512 bit
small 1K, 2k,4k,8k


private void allocate(PoolThreadCache cache, PooledByteBuf<T> buf, final int reqCapacity) {
        final int normCapacity = normalizeCapacity(reqCapacity);
        if (isTinyOrSmall(normCapacity)) { // capacity < pageSize
            // 一页大小分配
            int tableIdx;
            PoolSubpage<T>[] table;
            boolean tiny = isTiny(normCapacity);
            if (tiny) { // < 512
                if (cache.allocateTiny(this, buf, reqCapacity, normCapacity)) {
                    //优先开始从已经不在使用的哪些被回收的子页分配,注意回收时，不是把整页都回收，而是把那一页里面的子页回收
                    return;
                }
                tableIdx = tinyIdx(normCapacity);
                table = tinySubpagePools;
            } else {
                if (cache.allocateSmall(this, buf, reqCapacity, normCapacity)) {
                    //优先开始从已经不在使用的哪些被回收的子页分配
                    return;
                }
                tableIdx = smallIdx(normCapacity);
                table = smallSubpagePools;
            }
			//如果没有被回收的子页，那么从正在使用的一页中分配
            final PoolSubpage<T> head = table[tableIdx];

            synchronized (head) {
                final PoolSubpage<T> s = head.next;
                if (s != head) {
                    //取到指定规格的正在使用的子页
                    assert s.doNotDestroy && s.elemSize == normCapacity;
                    //子页分配，其实就是++，用于计算偏移量
                    long handle = s.allocate();
                    assert handle >= 0;
                    //最后通过chunk分配
                    s.chunk.initBufWithSubpage(buf, handle, reqCapacity);
                    if (tiny) {
                        allocationsTiny.increment();
                    } else {
                        allocationsSmall.increment();
                    }
                    return;
                }
            }
            //没有指定规格大小的子页，那么
            allocateNormal(buf, reqCapacity, normCapacity);
            return;
        }
        if (normCapacity <= chunkSize) {
            // 大于pagesize小于 整个chunksize大小分配
            if (cache.allocateNormal(this, buf, reqCapacity, normCapacity)) {
                // was able to allocate out of the cache so move on
                return;
            }
            allocateNormal(buf, reqCapacity, normCapacity);
        } else {
            // 超过chunksize大小的分配，注意，这个分配不会放入池中
            // Huge allocations are never served via the cache so just call allocateHuge
            allocateHuge(buf, reqCapacity);
        }
    }

PoolChunk

1
2
3
4
5
6
7
8
9
10
11
12

subpageOverflowMask  = ~(pageSize-1)
加入 默认pagesize是 8k = 2^13
~(0010 0000 0000 0000 - 0000 0000 0000 0001) = 1110 0000 0000 0000
    就是说normCapacity的容量单位与subpageOverflowMask不等于，说明大小大于一页大小
    long allocate(int normCapacity) {
        if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize
            return allocateRun(normCapacity);
        } else {
            return allocateSubpage(normCapacity);
        }
    }

请先了解buddy算法

多页分配
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

  private long allocateRun(int normCapacity) {
      //默认是8k的一页的大小，那么一页偏移量就是13，
      // 最大的深度11 ，指定的大小进来，那么会得到在二叉树的哪个深度
      // 最大的深度就是叶子节点，都是一群8k大小的page
      // 那么假设这个指定大小的 8k*2=2^14，那么 11 - （14-13），那么就在第10层
      // 以此类推
        int d = maxOrder - (log2(normCapacity) - pageShifts);
        int id = allocateNode(d);
        if (id < 0) {
            return id;
        }
        freeBytes -= runLength(id);
        return id;
    }

memoryMap：为了搜索块中至少有请求大小可用的第一个偏移量，我们构造了一个完整的平衡二叉树，并将其存储在一个数组（就像堆一样）
    在memoryMap中用符号对树进行编码：
    memoryMap[id]=x => 在以id为根的子树中，第一个可以自由分配的节点位于深度x（从depth=0开始计算），也就是说，在深度[depth_of_id，x]处，当我们分配空闲节点时，没有节点是空闲的，我们更新存储在memoryMap中的值，以使属性保持初始化-在开始时，我们通过在每个节点存储一个节点的深度来构造memoryMap数组，即memoryMap[id]=depth_of_id

 *
    
  private int allocateNode(int d) {
        int id = 1;//id=1 是二叉树的根
      //假设深度是10，那么 2^10-1 ,然后取反
      // 1111 1100 0000 0000
        int initial = - (1 << d); // has last d bits = 0 and rest all = 1
        byte val = value(id); //获取id为根可分配的子树深度
        if (val > d) { // 无法使用
            //如果深度大于指定深度，那么说明不可分配
            return -1;
        }
        while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0
           // 可用深度小于指定深度时，并且id走移动次数没有超过指定深度
            id <<= 1; //获得子树的下标
            val = value(id); // 获取以左子树为根的可用深度
            if (val > d) {
                //如果左子树可用深度大于指定深度，那么获取右子树
                id ^= 1;
                val = value(id);//取可用深度
            }
        }
    // 这里就一定能获取到可用深度的根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);
    //那么这个根为id的数就不可用了，被占用了
        setValue(id, unusable); // mark as unusable
        updateParentsAlloc(id); //更新父节点的可用深度
        return id;
    }



    private int runLength(int id) {
        // 表示树中节点“id”支持的大小（以字节为单位）
        return 1 << log2ChunkSize - depth(id);
        //log2ChunkSize 默认24，指定id为10的话，那么14，然后1<<14就是16k
        
    }
一页分配

1598843240090

子页初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
id 就是 memoryMapIdx
    
    // 这个方法计算 当前id对应树节点指定的页的偏移量
 private int runOffset(int id) {
        // represents the 0-based offset in #bytes from start of the byte-array chunk
        int shift = id ^ 1 << depth(id);
        return shift * runLength(id);
    }


PoolSubpage(PoolSubpage<T> head, PoolChunk<T> chunk, int memoryMapIdx, int runOffset, int pageSize, int elemSize) {
        this.chunk = chunk;
        this.memoryMapIdx = memoryMapIdx; //树节点
        this.runOffset = runOffset;      //页在整个chunk的偏移量
        this.pageSize = pageSize; //页大小
        bitmap = new long[pageSize >>> 10]; // pageSize / 16 / 64，默认数组大小为 8
        init(head, elemSize);
    }

    void init(PoolSubpage<T> head, int elemSize) {
        
        //elemSize 是规格化的大小，一定是16的倍数，假设是256
        // 那么numAvail就是32 0010 0000
        doNotDestroy = true;
        this.elemSize = elemSize;
        if (elemSize != 0) {
            // 这个请求的页大小可以分成多少子页
            maxNumElems = numAvail = pageSize / elemSize;
            nextAvail = 0;
            // 右移6为就是一个64，此时可用个数32，
            bitmapLength = maxNumElems >>> 6;
            if ((maxNumElems & 63) != 0) {
                
                bitmapLength ++;
            }
			//最后获取到位图的长度，初始化
            for (int i = 0; i < bitmapLength; i ++) {
                bitmap[i] = 0;
            }
        }
       // 头插法/插入以head为头的链表
        addToPool(head);
    }

//子页分配算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
//这是为了降低内碎片采用的，通过area（所属区域）获取子页的头
private long allocateSubpage(int normCapacity) {
        // 获取PoolArena拥有的PoolSubPage池的头部并在其上进行同步。
        // 这是需要的，因为我们可能会把它添加回来，从而改变链表结构。
        PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
        synchronized (head) {
            
            int d = maxOrder; // 子页面只能从页面（即叶）分配
            // 获取有可用深度子树的id
            int id = allocateNode(d);
            if (id < 0) {
                return id;
            }
			
            final PoolSubpage<T>[] subpages = this.subpages;
            final int pageSize = this.pageSize;

            freeBytes -= pageSize;
			//转成 subpages表的 id
            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();
        }
    }

--- PoolArea的方法
 PoolSubpage<T> findSubpagePoolHead(int elemSize) {
        int tableIdx;
        PoolSubpage<T>[] table;
        if (isTiny(elemSize)) { // < 512
            tableIdx = elemSize >>> 4;
            table = tinySubpagePools;
        } else {
            tableIdx = 0;
            elemSize >>>= 10;
            while (elemSize != 0) {
                elemSize >>>= 1;
                tableIdx ++;
            }
            table = smallSubpagePools;
        }
		// 会根据计算的idx取出 缓存页的头
        return table[tableIdx];
    }


--- PoolSubpage的方法
 long allocate() {
        if (elemSize == 0) {
            return toHandle(0);
        }

        if (numAvail == 0 || !doNotDestroy) {
            return -1;
        }
		// 用位图 获取下一个可用点，刚开始为0
        final int bitmapIdx = getNextAvail();
        int q = bitmapIdx >>> 6;//获取到位图中的下标，大范围下标
        int r = bitmapIdx & 63; //获取位图中小范围下标
        assert (bitmap[q] >>> r & 1) == 0;
        bitmap[q] |= 1L << r; //把指定位置设成1

        if (-- numAvail == 0) { //可用点--
            removeFromPool();
        }
		//高32为是 位图，低32位是 树节点
        return toHandle(bitmapIdx);
    }
页内分配
tiny
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

  boolean allocateTiny(PoolArena<?> area, PooledByteBuf<?> buf, int reqCapacity, int normCapacity) {
        return allocate(cacheForTiny(area, normCapacity), buf, reqCapacity);
    }

PoolArena
  private MemoryRegionCache<?> cacheForTiny(PoolArena<?> area, int normCapacity) {
      //由于 normCapacity的大小最大 0001 1111 1111
      // 这个算法会右移四位，取id，那么表的长度就是32
        int idx = PoolArena.tinyIdx(normCapacity);
        if (area.isDirect()) {
            //从指定的缓存表中去指定id位置的 page缓存
            return cache(tinySubPageDirectCaches, idx);
        }
        return cache(tinySubPageHeapCaches, idx);
    }

PoolThreadCache
    private boolean allocate(MemoryRegionCache<?> cache, PooledByteBuf buf, int reqCapacity) {
        if (cache == null) {
            // no cache found so just return false here
            return false;
        }
        boolean allocated = cache.allocate(buf, reqCapacity);
        if (++ allocations >= freeSweepAllocationThreshold) {
            allocations = 0;
            trim();
        }
        return allocated;
    }

MemoryRegionCache 
        public final boolean allocate(PooledByteBuf<T> buf, int reqCapacity) {
            Entry<T> entry = queue.poll();
            if (entry == null) {
                return false;
            }
            // 此时chunk开始分配
            initBuf(entry.chunk, entry.handle, buf, reqCapacity);
            entry.recycle();

            // allocations is not thread-safe which is fine as this is only called from the same thread all time.
            ++ allocations;
            return true;
        }
small
1
2

跟tiny差不多
真正的ByteBuf分配
1
2
3
4
5
6
7
8
9
10
11
12
13

void initBuf(PooledByteBuf<T> buf, long handle, int reqCapacity) {
      int memoryMapIdx = memoryMapIdx(handle);
      int bitmapIdx = bitmapIdx(handle);
      if (bitmapIdx == 0) {
          byte val = value(memoryMapIdx);
          assert val == unusable : String.valueOf(val);
          buf.init(this, handle, runOffset(memoryMapIdx), reqCapacity, runLength(memoryMapIdx),
                   arena.parent.threadCache());
      } else {
          initBufWithSubpage(buf, handle, bitmapIdx, reqCapacity);
      }
  }

池的回收

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
AbstractReferenceCountedByteBuf
   public boolean release() {
        return release0(1);
    }

AbstractReferenceCountedByteBuf
private boolean release0(int decrement) {
        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;
            }
        }
    }

PooledByteBuf
    protected final void deallocate() {
        if (handle >= 0) {
            final long handle = this.handle;
            this.handle = -1;
            memory = null;
            chunk.arena.free(chunk, handle, maxLength, cache);
            recycle();
        }
    }
PoolArea
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
PoolArea
 void free(PoolChunk<T> chunk, long handle, int normCapacity, PoolThreadCache cache) {
        if (chunk.unpooled) {
            int size = chunk.chunkSize();
            destroyChunk(chunk);
            activeBytesHuge.add(-size);
            deallocationsHuge.increment();
        } else {
            SizeClass sizeClass = sizeClass(normCapacity);
            if (cache != null && cache.add(this, chunk, handle, normCapacity, sizeClass)) {
                // 不是多页形式的就直接缓存就行
                // cached so not free it.
                return;
            }

            freeChunk(chunk, handle, sizeClass);
        }
    }



 void freeChunk(PoolChunk<T> chunk, long handle, SizeClass sizeClass) {
        final boolean destroyChunk;
        synchronized (this) {
            switch (sizeClass) {
            case Normal:
                ++deallocationsNormal;
                break;
            case Small:
                ++deallocationsSmall;
                break;
            case Tiny:
                ++deallocationsTiny;
                break;
            default:
                throw new Error();
            }
            destroyChunk = !chunk.parent.free(chunk, handle);
        }
        if (destroyChunk) {
            // 持有同步锁时不需要调用destroyChunk。
            //
            destroyChunk(chunk);
        }
    }
        @Override
        protected void destroyChunk(PoolChunk<ByteBuffer> chunk) {
            if (PlatformDependent.useDirectBufferNoCleaner()) {
                PlatformDependent.freeDirectNoCleaner(chunk.memory);
            } else {
                PlatformDependent.freeDirectBuffer(chunk.memory);
            }
        }

free Chunk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

 boolean free(PoolChunk<T> chunk, long handle) {
        chunk.free(handle);
        if (chunk.usage() < minUsage) {
            remove(chunk);
            // Move the PoolChunk down the PoolChunkList linked-list.
            return move0(chunk);
        }
        return true;
    }

//可用深度重新设置
 void free(long handle) {
        int memoryMapIdx = memoryMapIdx(handle);
        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;
                }
            }
        }
        freeBytes += runLength(memoryMapIdx);
        setValue(memoryMapIdx, depth(memoryMapIdx));
        updateParentsFree(memoryMapIdx);
    }


 private boolean move0(PoolChunk<T> chunk) {
        if (prevList == null) {
            // There is no previous PoolChunkList so return false which result in having the PoolChunk destroyed and
            // all memory associated with the PoolChunk will be released.
            assert chunk.usage() == 0;
            return false;
        }
        return prevList.move(chunk);
    }

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

        if (chunk.usage() < minUsage) {
            // Move the PoolChunk down the PoolChunkList linked-list.
            return move0(chunk);
        }

        // PoolChunk fits into this PoolChunkList, adding it here.
        add0(chunk);
        return true;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

  private void recycle() {
        Recycler.Handle recyclerHandle = this.recyclerHandle;
        if (recyclerHandle != null) {
            ((Recycler<Object>) recycler()).recycle(this, recyclerHandle);
        }
    }

public final boolean recycle(T o, Handle handle) {
        if (handle == NOOP_HANDLE) {
            return false;
        }

        DefaultHandle h = (DefaultHandle) handle;
        if (h.stack.parent != this) {
            return false;
        }
        if (o != h.value) {
            throw new IllegalArgumentException("o does not belong to handle");
        }
        h.recycle();
        return true;
    }

DefaultHandle
  public void recycle() {
            stack.push(this);
        }

Stack
  void push(DefaultHandle item) {
            Thread currentThread = Thread.currentThread();
            if (thread == currentThread) {
                // The current Thread is the thread that belongs to the Stack, we can try to push the object now.
                pushNow(item);
            } else {
                // The current Thread is not the one that belongs to the Stack, we need to signal that the push
                // happens later.
                pushLater(item, currentThread);
            }
        }

        private void pushNow(DefaultHandle item) {
            if ((item.recycleId | item.lastRecycledId) != 0) {
                throw new IllegalStateException("recycled already");
            }
            item.recycleId = item.lastRecycledId = OWN_THREAD_ID;

            int size = this.size;
            if (size >= maxCapacity || dropHandle(item)) {
                // Hit the maximum capacity or should drop - drop the possibly youngest object.
                return;
            }
            if (size == elements.length) {
                elements = Arrays.copyOf(elements, min(size << 1, maxCapacity));
            }

            elements[size] = item;
            this.size = size + 1;
        }
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家