flowchart TB
    subgraph "P的mcache 内存分配缓存"
        MCACHE[mcache结构]
        TINY[tiny分配器<br/>微小对象<16B]
        ALLOC[alloc数组<br/>136个span class]
        STACK[stackcache<br/>栈缓存]
        
        MCACHE --> TINY
        MCACHE --> ALLOC
        MCACHE --> STACK
    end
    
    subgraph "mcentral 中心缓存"
        CENTRAL[mcentral数组<br/>按size class索引]
        PARTIAL[partial链表<br/>部分空闲span]
        FULL[full链表<br/>已满span]
        
        CENTRAL --> PARTIAL
        CENTRAL --> FULL
    end
    
    subgraph "mheap 全局堆"
        HEAP[mheap结构]
        PAGES[pages页分配器<br/>radix tree]
        ARENAS[arenas数组<br/>管理64MB块]
        SPANS[allspans<br/>所有span记录]
        
        HEAP --> PAGES
        HEAP --> ARENAS
        HEAP --> SPANS
    end
    
    subgraph "span 内存块"
        SPAN1[mspan<br/>8KB页]
        SPAN2[mspan<br/>16KB页]
        SPAN3[mspan<br/>32KB页]
        BITMAP[allocBits<br/>分配位图]
        
        SPAN1 --> BITMAP
        SPAN2 --> BITMAP
        SPAN3 --> BITMAP
    end
    
    subgraph "操作系统"
        OS[OS内存<br/>mmap/VirtualAlloc]
    end
    
    ALLOC -.span耗尽.-> CENTRAL
    CENTRAL -.span耗尽.-> HEAP
    HEAP -.内存不足.-> OS
    
    HEAP -.返还.-> OS
    CENTRAL -.归还.-> HEAP
    ALLOC -.归还.-> CENTRAL
    
    subgraph "分配路径"
        REQ[分配请求]
        SIZECHECK{对象大小?}
        TINYPATH[tiny路径<br/>≤16B无指针]
        SMALLPATH[small路径<br/>≤32KB]
        LARGEPATH[large路径<br/>>32KB]
        
        REQ --> SIZECHECK
        SIZECHECK -->|tiny| TINYPATH
        SIZECHECK -->|small| SMALLPATH
        SIZECHECK -->|large| LARGEPATH
        
        TINYPATH --> TINY
        SMALLPATH --> ALLOC
        LARGEPATH --> HEAP
    end

分配策略：
1. 多个tiny对象合并到一个16B块中
2. 减少内存碎片和分配次数
3. 从P的mcache.tiny分配
4. 例子：小整数、bool、小字符串

分配策略：
1. 根据对象大小映射到67个size class之一
2. 从mcache对应span的分配位图查找空闲slot
3. span满时从mcentral获取新span
4. 例子：大部分Go对象、小slice、小map

分配策略：
1. 直接从mheap分配
2. 不经过mcache和mcentral
3. 分配整数个页（8KB的倍数）
4. 例子：大数组、大slice、大map

type mspan struct {
    next     *mspan         // 链表指针
    prev     *mspan         // 链表指针
    startAddr uintptr       // span起始地址
    npages    uintptr       // span包含的页数
    
    nelems      uintptr     // span中object数量
    elemsize    uintptr     // object大小
    spanclass   spanClass   // size class and noscan
    
    allocCount  uint16      // 已分配object数量
    allocBits   *gcBits     // 分配位图
    gcmarkBits  *gcBits     // GC标记位图
    
    sweepgen    uint32      // sweep generation
    allocCache  uint64      // allocBits的缓存
    
    // 链表管理
    state       mSpanStateBox  // mSpanInUse等
    needzero    uint8          // 是否需要清零
    divMul      uint32         // 用于快速除法
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    // 1. 快速路径：tiny对象
    if size <= maxTinySize && typ.Kind_&kindNoPointers != 0 {
        off := c.tinyoffset
        // 对齐
        if size&7 == 0 {
            off = alignUp(off, 8)
        } else if goarch.PtrSize == 4 && size == 12 {
            off = alignUp(off, 8)
        } else if size&3 == 0 {
            off = alignUp(off, 4)
        } else if size&1 == 0 {
            off = alignUp(off, 2)
        }
        if off+size <= maxTinySize && c.tiny != 0 {
            // 有足够空间，直接分配
            x = unsafe.Pointer(c.tiny + off)
            c.tinyoffset = off + size
            return x
        }
        // 分配新的tiny块
        span = c.alloc[tinySpanClass]
        v := nextFreeFast(span)
        if v == 0 {
            v, span = c.nextFree(tinySpanClass)
        }
        x = unsafe.Pointer(v)
        (*[2]uint64)(x)[0] = 0
        (*[2]uint64)(x)[1] = 0
        c.tiny = uintptr(x)
        c.tinyoffset = size
        return x
    }

    // 2. 小对象路径
    if size <= maxSmallSize {
        if typ.Kind_&kindNoPointers != 0 {
            span = c.alloc[tSpanClass]
        }
        // 从span分配
        v := nextFreeFast(span)
        if v == 0 {
            v, span = c.nextFree(spc)
        }
        x = unsafe.Pointer(v)
        if needzero && span.needzero != 0 {
            memclrNoHeapPointers(x, size)
        }
        return x
    }

    // 3. 大对象路径
    span = c.allocLarge(size, typ)
    x = unsafe.Pointer(span.base())
    return x
}

func nextFreeFast(s *mspan) gclinkptr {
    theBit := sys.TrailingZeros64(s.allocCache)
    if theBit < 64 {
        result := s.freeindex + uintptr(theBit)
        if result < s.nelems {
            freeidx := result + 1
            if freeidx%64 == 0 && freeidx != s.nelems {
                return 0  // 缓存用完，走慢路径
            }
            s.allocCache >>= uint(theBit + 1)
            s.freeindex = freeidx
            s.allocCount++
            return gclinkptr(result*s.elemsize + s.base())
        }
    }
    return 0
}

+------------------+
| Stack            |  栈向下增长
+------------------+
| ↓                |
|                  |
| ↑                |
+------------------+
| Heap             |  堆向上增长
| - arenas         |  64MB对齐的大块
| - spans          |  管理元数据
+------------------+
| .bss/.data       |  全局变量
+------------------+
| .text            |  代码段
+------------------+

每个arena = 64MB = 8192个page(8KB)
arena metadata存储在heapArena结构中：
- bitmap：标记哪些字包含指针
- spans：指向覆盖该区域的mspan

mspan结构 (metadata)
+------------------+
| startAddr        | ------+
| npages           |       |
| elemsize         |       |
| allocBits        |       |
+------------------+       |
                           |
实际内存                    |
+------------------+ <-----+
| object 0         |
+------------------+
| object 1         |
+------------------+
| object 2         |
+------------------+
| ...              |
+------------------+

// size到class的映射表
var class_to_size = [_NumSizeClasses]uint16{
    0,    8,    16,   24,   32,   48,   64,   80,
    96,   112,  128,  144,  160,  176,  192,  208,
    224,  240,  256,  288,  320,  352,  384,  416,
    448,  480,  512,  576,  640,  704,  768,  896,
    1024, 1152, 1280, 1408, 1536, 1792, 2048, 2304,
    2688, 3072, 3200, 3456, 4096, 4864, 5376, 6144,
    6528, 6784, 6912, 8192, 9472, 9728, 10240, 10880,
    12288, 13568, 14336, 16384, 18432, 19072, 20480, 21760,
    24576, 27264, 28672, 32768,
}

// 快速查找size class
func sizeToClass(size uintptr) uint8 {
    if size > maxSmallSize {
        throw("invalid size")
    }
    if size > 1024-8 {
        return uint8(size_to_class128[(size-1024+127)>>7])
    }
    return uint8(size_to_class8[(size-1+smallSizeDiv-1)/smallSizeDiv])
}

type mcentral struct {
    spanclass spanClass    // size class
    partial  [2]spanSet    // 部分空闲的span列表
    full     [2]spanSet    // 已满的span列表
}

// 从mcentral获取span
func (c *mcentral) cacheSpan() *mspan {
    sg := mheap_.sweepgen
retry:
    // 1. 从partial列表获取
    var s *mspan
    if s = c.partial[sg%2].pop(); s != nil {
        goto havespan
    }
    
    // 2. 从full列表获取（已清扫的span）
    for s = c.full[sg%2].pop(); s != nil; s = c.full[sg%2].pop() {
        if s.sweep(false) {
            goto havespan
        }
    }
    
    // 3. 从mheap申请新span
    s = c.grow()
    if s == nil {
        return nil
    }

havespan:
    // 设置span为已缓存状态
    n := int(s.nelems) - int(s.allocCount)
    if n == 0 || s.freeindex == s.nelems {
        throw("span has no free objects")
    }
    return s
}

type mheap struct {
    lock mutex
    pages pageAlloc       // 页分配器
    
    allspans []*mspan    // 所有span
    arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena
    
    central [numSpanClasses]struct {
        mcentral mcentral
        pad      [cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize]byte
    }
}

// 分配npages页
func (h *mheap) alloc(npages uintptr, spanclass spanClass) *mspan {
    // 1. 从页分配器获取连续页
    base, scav := h.pages.alloc(npages)
    if base == 0 {
        // 向OS申请更多内存
        if !h.grow(npages) {
            return nil
        }
        base, scav = h.pages.alloc(npages)
        if base == 0 {
            throw("grew heap, but no adequate free space found")
        }
    }
    
    // 2. 初始化span
    s := h.allocMSpanLocked()
    s.init(base, npages)
    s.spanclass = spanclass
    
    // 3. 设置arena映射
    h.setSpans(s.base(), npages, s)
    
    return s
}

sequenceDiagram
    autonumber
    participant User as 用户代码
    participant Compiler as 编译器
    participant G as Goroutine
    participant P as P(处理器)
    participant mcache as mcache<br/>(P的内存缓存)
    participant mspan as mspan<br/>(当前span)
    participant mcentral as mcentral<br/>(中央缓存)
    
    User->>Compiler: obj := new(T)
    Compiler->>G: mallocgc(size, typ, needzero)
    
    alt size <= 16 byte (Tiny对象)
        G->>P: 获取当前P
        P->>mcache: 访问P.mcache
        mcache->>mcache: 检查tiny块<br/>(tiny, tinyoffset)
        
        alt tiny块有足够空间
            mcache->>mcache: 从tiny块分配<br/>offset += size
            mcache-->>G: 返回tiny+offset
        else tiny块空间不足
            mcache->>mspan: 访问tiny sizeclass的span
            mspan->>mspan: nextFreeFast()<br/>查找空闲对象
            mspan-->>mcache: 返回新tiny块
            mcache->>mcache: 替换tiny块<br/>offset = size
            mcache-->>G: 返回新地址
        end
    else 16 < size <= 32KB (Small对象)
        G->>G: 计算sizeclass<br/>size → sizeclass
        G->>mcache: 获取对应span<br/>alloc[sizeclass]
        mcache->>mspan: 访问mspan
        
        alt span有空闲对象
            mspan->>mspan: nextFreeFast()<br/>快速路径
            alt allocCache非零
                mspan->>mspan: ctz(allocCache)<br/>找到bit位置
                mspan->>mspan: 清除bit<br/>标记已分配
                mspan-->>mcache: 返回对象地址
            else allocCache为零
                mspan->>mspan: nextFree()<br/>慢速路径
                mspan->>mspan: 刷新allocCache<br/>从allocBits加载
                mspan->>mspan: 再次ctz查找
                mspan-->>mcache: 返回对象地址
            end
            mcache-->>G: 返回对象指针
        else span已满
            G->>mcentral: refill(sizeclass)
            mcentral->>mcentral: cacheSpan()<br/>获取新span
            
            alt nonempty列表有span
                mcentral->>mcentral: 从nonempty获取
                mcentral-->>mcache: 返回span
            else 从empty列表获取
                mcentral->>mcentral: sweep并获取
                mcentral-->>mcache: 返回span
            else 都无可用span
                mcentral->>mcentral: grow(sizeclass)
                mcentral->>mcentral: 向mheap申请<br/>alloc(npages)
                mcentral->>mspan: 切分新span
                mcentral-->>mcache: 返回新span
            end
            
            mcache->>mcache: 替换原span<br/>alloc[sizeclass] = newSpan
            mcache->>mspan: nextFreeFast()
            mspan-->>mcache: 返回对象地址
            mcache-->>G: 返回对象指针
        end
    end
    
    G->>G: 零值初始化(如需)
    G-->>User: 返回对象指针

sequenceDiagram
    autonumber
    participant User as 用户代码
    participant G as Goroutine
    participant mheap as mheap<br/>(全局堆)
    participant PageCache as PageCache<br/>(页缓存)
    participant Arena as Arena<br/>(内存区域)
    participant OS as 操作系统
    
    User->>G: obj := make([]T, largeN)
    G->>G: mallocgc(size, typ, false)
    G->>G: 判断size > 32KB
    G->>mheap: alloc(npages, sizeclass=0)
    
    mheap->>mheap: 加全局锁<br/>lock(&mheap.lock)
    
    alt 1. 尝试PageCache
        mheap->>PageCache: 查找npages页<br/>(P本地页缓存)
        
        alt PageCache命中
            PageCache->>PageCache: 取出连续页
            PageCache-->>mheap: 返回页地址
            mheap->>mheap: 初始化span<br/>(sizeclass=0, npages)
            mheap-->>mheap: 解锁
            mheap-->>G: 返回span
        end
    end
    
    alt 2. 尝试free tree查找
        mheap->>mheap: 查找free tree<br/>bestFit(npages)
        
        alt 找到合适span
            mheap->>mheap: 从tree移除span
            
            alt span大小匹配
                mheap->>mheap: 直接使用
                mheap-->>mheap: 解锁
                mheap-->>G: 返回span
            else span过大
                mheap->>mheap: 切分span<br/>split(span, npages)
                mheap->>mheap: 剩余部分放回tree
                mheap-->>mheap: 解锁
                mheap-->>G: 返回span
            end
        end
    end
    
    alt 3. 从Arena申请新内存
        mheap->>mheap: grow(npages)
        mheap->>Arena: sysReserve(size)
        Arena->>OS: mmap(PROT_NONE)
        OS-->>Arena: 返回虚拟地址
        Arena->>OS: madvise(MADV_NOHUGEPAGE)
        OS-->>Arena: 配置页表
        Arena-->>mheap: 返回新区域
        
        mheap->>mheap: 创建新span
        mheap->>mheap: 更新arena映射<br/>setSpans()
        mheap-->>mheap: 解锁
        mheap-->>G: 返回新span
    end
    
    G->>G: 设置span.sizeclass=0<br/>span.elemsize=size
    G-->>User: 返回对象指针

sequenceDiagram
    autonumber
    participant mcache as mcache<br/>(P的缓存)
    participant mcentral as mcentral<br/>(中央缓存)
    participant nonempty as nonempty<br/>列表
    participant empty as empty<br/>列表
    participant span1 as Span1<br/>(被sweep)
    participant mheap as mheap<br/>(全局堆)
    
    mcache->>mcentral: refill(sizeclass)
    mcentral->>mcentral: lock(&c.lock)
    
    alt 1. 从nonempty获取
        mcentral->>nonempty: 遍历nonempty列表
        
        alt 找到有空闲对象的span
            nonempty->>mcentral: 返回span
            mcentral->>mcentral: 从列表移除
            mcentral-->>mcentral: unlock
            mcentral-->>mcache: 返回span
        end
    end
    
    alt 2. 从empty列表sweep
        mcentral->>empty: 遍历empty列表
        
        loop 扫描empty列表
            mcentral->>span1: 检查span状态
            
            alt span未sweep
                mcentral->>span1: sweep(s, true)
                span1->>span1: 扫描allocBits<br/>查找可回收对象
                
                alt 找到可回收对象
                    span1->>span1: 重置allocCount<br/>刷新allocCache
                    span1-->>mcentral: 返回span
                    mcentral->>mcentral: 从empty移除
                    mcentral-->>mcentral: unlock
                    mcentral-->>mcache: 返回span
                else 完全空闲
                    span1-->>mcentral: 标记可释放
                    mcentral->>mcentral: 继续扫描
                else 完全满
                    mcentral->>mcentral: 保留在empty
                end
            end
        end
    end
    
    alt 3. 向mheap申请新span
        mcentral->>mcentral: grow(sizeclass)
        mcentral->>mcentral: unlock暂时释放锁
        
        mcentral->>mheap: alloc(npages)
        mheap->>mheap: 分配连续页<br/>(前述大对象流程)
        mheap-->>mcentral: 返回新span
        
        mcentral->>mcentral: lock重新获取锁
        mcentral->>span1: 初始化新span
        span1->>span1: 设置sizeclass<br/>nelems, elemsize
        span1->>span1: 初始化allocBits<br/>全0(全空闲)
        
        mcentral->>nonempty: 将新span加入nonempty
        mcentral-->>mcentral: unlock
        mcentral-->>mcache: 返回新span
    end

// 不推荐：频繁分配小对象
for i := 0; i < 1000000; i++ {
    s := fmt.Sprintf("%d", i)  // 每次分配新字符串
    process(s)
}

// 推荐：复用buffer
var buf bytes.Buffer
for i := 0; i < 1000000; i++ {
    buf.Reset()
    fmt.Fprintf(&buf, "%d", i)
    process(buf.String())
}

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func process() {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buf)
    buf.Reset()
    // 使用buf
}

// 不推荐：append导致多次分配
var data []int
for i := 0; i < 10000; i++ {
    data = append(data, i)
}

// 推荐：预分配容量
data := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    data = append(data, i)
}