超干貨！徹底搞懂Golang內(nèi)存管理和垃圾回收

//from runtime.gosizeclasses.go
// class  bytes/obj  bytes/span  objects  tail waste  max waste//     1          8        8192     1024           0     87.50%//     2         16        8192      512           0     43.75%//     3         32        8192      256           0     46.88%//     4         48        8192      170          32     31.52%//     5         64        8192      128           0     23.44%//     6         80        8192      102          32     19.07%//     7         96        8192       85          32     15.95%//     8        112        8192       73          16     13.56%//     9        128        8192       64           0     11.72%//    10        144        8192       56         128     11.82%//    11        160        8192       51          32      9.73%//    12        176        8192       46          96      9.59%//    13        192        8192       42         128      9.25%//    14        208        8192       39          80      8.12%//    15        224        8192       36         128      8.15%//    16        240        8192       34          32      6.62%//    17        256        8192       32           0      5.86%//    18        288        8192       28         128     12.16%//    19        320        8192       25         192     11.80%//    20        352        8192       23          96      9.88%//    21        384        8192       21         128      9.51%//    22        416        8192       19         288     10.71%//    23        448        8192       18         128      8.37%//    24        480        8192       17          32      6.82%//    25        512        8192       16           0      6.05%//    26        576        8192       14         128     12.33%//    27        640        8192       12         512     15.48%//    28        704        8192       11         448     13.93%//    29        768        8192       10         512     13.94%//    30        896        8192        9         128     15.52%//    31       1024        8192        8           0     12.40%//    32       1152        8192        7         128     12.41%//    33       1280        8192        6         512     15.55%//    34       1408       16384       11         896     14.00%//    35       1536        8192        5         512     14.00%//    36       1792       16384        9         256     15.57%//    37       2048        8192        4           0     12.45%//    38       2304       16384        7         256     12.46%//    39       2688        8192        3         128     15.59%//    40       3072       24576        8           0     12.47%//    41       3200       16384        5         384      6.22%//    42       3456       24576        7         384      8.83%//    43       4096        8192        2           0     15.60%//    44       4864       24576        5         256     16.65%//    45       5376       16384        3         256     10.92%//    46       6144       24576        4           0     12.48%//    47       6528       32768        5         128      6.23%//    48       6784       40960        6         256      4.36%//    49       6912       49152        7         768      3.37%//    50       8192        8192        1           0     15.61%//    51       9472       57344        6         512     14.28%//    52       9728       49152        5         512      3.64%//    53      10240       40960        4           0      4.99%//    54      10880       32768        3         128      6.24%//    55      12288       24576        2           0     11.45%//    56      13568       40960        3         256      9.99%//    57      14336       57344        4           0      5.35%//    58      16384       16384        1           0     12.49%//    59      18432       73728        4           0     11.11%//    60      19072       57344        3         128      3.57%//    61      20480       40960        2           0      6.87%//    62      21760       65536        3         256      6.25%//    63      24576       24576        1           0     11.45%//    64      27264       81920        3         128     10.00%//    65      28672       57344        2           0      4.91%//    66      32768       32768        1           0     12.50%

// class  bytes/obj  bytes/span  objects  tail waste  max waste//     1          8        8192     1024           0     87.50%//     2         16        8192      512           0     43.75%//     3         32        8192      256           0     46.88%

// noscan為false代表對象包含指針func makeSpanClass(sizeclass uint8, noscan bool) spanClass {    return spanClass(sizeclass<<1) | spanClass(bool2int(noscan))}

span class = 3 << 1 | 0 = 6

//from runtime.gomalloc.go
var sizeclass uint8//step1: 確定規(guī)格sizeClassif size <= smallSizeMax-8 {    sizeclass = size_to_class8[divRoundUp(size, smallSizeDiv)]} else {    sizeclass = size_to_class128[divRoundUp(size-smallSizeMax, largeSizeDiv)]}size = uintptr(class_to_size[sizeclass])// size class到span classspc := makeSpanClass(sizeclass, noscan)//step2: 分配對應(yīng)spanClass 的 spanspan = c.alloc[spc]v := nextFreeFast(span)if v == 0 {    v, span, shouldhelpgc = c.nextFree(spc)}x = unsafe.Pointer(v)if needzero &amp;&amp; span.needzero != 0 {    memclrNoHeapPointers(unsafe.Pointer(v), size)}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {    ...    shouldhelpgc := false    // 分配的對象小于 32K byte    if size <= maxSmallSize {        ...    } else {        shouldhelpgc = true        ...    }    ...    // gcShouldStart() 函數(shù)進行觸發(fā)條件檢測    if shouldhelpgc && gcShouldStart(false) {        // gcStart() 函數(shù)進行垃圾回收        gcStart(gcBackgroundMode, false)    }}

// GC runs a garbage collection and blocks the caller until the// garbage collection is complete. It may also block the entire// program.func GC() {    gcStart(gcForceBlockMode, false)}

// gcShouldStart returns true if the exit condition for the _GCoff// phase has been met. The exit condition should be tested when// allocating.//// If forceTrigger is true, it ignores the current heap size, but// checks all other conditions. In general this should be false.func gcShouldStart(forceTrigger bool) bool {    return gcphase == _GCoff && (forceTrigger || memstats.heap_live >= memstats.gc_trigger) && memstats.enablegc && panicking == 0 && gcpercent >= 0}
//初始化的時候設(shè)置 GC 的觸發(fā)閾值func gcinit() {    _ = setGCPercent(readgogc())    memstats.gc_trigger = heapminimum    ...}// 啟動的時候通過 GOGC 傳遞百分比 x// 觸發(fā)閾值等于 x * defaultHeapMinimum (defaultHeapMinimum 默認是 4M)func readgogc() int32 {    p := gogetenv("GOGC")    if p == "off" {        return -1    }    if n, ok := atoi32(p); ok {        return n    }    return 100}

// gcStart 是 GC 的入口函數(shù)，根據(jù) gcMode 做處理。// 1. gcMode == gcBackgroundMode（后臺運行，也就是并行）, _GCoff -> _GCmark// 2. 否則 GCoff -> _GCmarktermination，這個時候就是主動 GCfunc gcStart(mode gcMode, forceTrigger bool) {    ...    //在后臺啟動 mark worker    if mode == gcBackgroundMode {        gcBgMarkStartWorkers()    }    ...    // Stop The World    systemstack(stopTheWorldWithSema)    ...    if mode == gcBackgroundMode {        // GC 開始前的準備工作
        //處理設(shè)置 GCPhase，setGCPhase 還會 開始寫屏障        setGCPhase(_GCmark)
        gcBgMarkPrepare() // Must happen before assist enable.        gcMarkRootPrepare()
        // Mark all active tinyalloc blocks. Since we're        // allocating from these, they need to be black like        // other allocations. The alternative is to blacken        // the tiny block on every allocation from it, which        // would slow down the tiny allocator.        gcMarkTinyAllocs()
        // Start The World        systemstack(startTheWorldWithSema)    } else {        ...    }}

func gcStart(mode gcMode, forceTrigger bool) {    ...    //在后臺啟動 mark worker    if mode == gcBackgroundMode {        gcBgMarkStartWorkers()    }}
func gcBgMarkStartWorkers() {    // Background marking is performed by per-P G's. Ensure that    // each P has a background GC G.    for _, p := range &allp {        if p == nil || p.status == _Pdead {            break        }        if p.gcBgMarkWorker == 0 {            go gcBgMarkWorker(p)            notetsleepg(&work.bgMarkReady, -1)            noteclear(&work.bgMarkReady)        }    }}// gcBgMarkWorker 是一直在后臺運行的，大部分時候是休眠狀態(tài)，通過 gcController 來調(diào)度func gcBgMarkWorker(_p_ *p) {    for {        // 將當前 goroutine 休眠，直到滿足某些條件        gopark(...)        ...        // mark 過程        systemstack(func() {        // Mark our goroutine preemptible so its stack        // can be scanned. This lets two mark workers        // scan each other (otherwise, they would        // deadlock). We must not modify anything on        // the G stack. However, stack shrinking is        // disabled for mark workers, so it is safe to        // read from the G stack.        casgstatus(gp, _Grunning, _Gwaiting)        switch _p_.gcMarkWorkerMode {        default:            throw("gcBgMarkWorker: unexpected gcMarkWorkerMode")        case gcMarkWorkerDedicatedMode:            gcDrain(&_p_.gcw, gcDrainNoBlock|gcDrainFlushBgCredit)        case gcMarkWorkerFractionalMode:            gcDrain(&_p_.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)        case gcMarkWorkerIdleMode:            gcDrain(&_p_.gcw, gcDrainIdle|gcDrainUntilPreempt|gcDrainFlushBgCredit)        }        casgstatus(gp, _Gwaiting, _Grunning)        })        ...    }}

// gcDrain scans roots and objects in work buffers, blackening grey// objects until all roots and work buffers have been drained.func gcDrain(gcw *gcWork, flags gcDrainFlags) {    ...    // Drain root marking jobs.    if work.markrootNext < work.markrootJobs {        for !(preemptible && gp.preempt) {            job := atomic.Xadd(&work.markrootNext, +1) - 1            if job >= work.markrootJobs {                break            }            markroot(gcw, job)            if idle && pollWork() {                goto done            }        }    }
    // 處理 heap 標記    // Drain heap marking jobs.    for !(preemptible && gp.preempt) {        ...        //從灰色列隊中取出對象        var b uintptr        if blocking {            b = gcw.get()        } else {            b = gcw.tryGetFast()            if b == 0 {                b = gcw.tryGet()            }        }        if b == 0 {            // work barrier reached or tryGet failed.            break        }        //掃描灰色對象的引用對象，標記為灰色，入灰色隊列        scanobject(b, gcw)    }}

func gcSweep(mode gcMode) {    ...    //阻塞式    if !_ConcurrentSweep || mode == gcForceBlockMode {        // Special case synchronous sweep.        ...        // Sweep all spans eagerly.        for sweepone() != ^uintptr(0) {            sweep.npausesweep++        }        // Do an additional mProf_GC, because all 'free' events are now real as well.        mProf_GC()        mProf_GC()        return    }
    // 并行式    // Background sweep.    lock(&sweep.lock)    if sweep.parked {        sweep.parked = false        ready(sweep.g, 0, true)    }    unlock(&sweep.lock)}

func bgsweep(c chan int) {    sweep.g = getg()
    lock(&sweep.lock)    sweep.parked = true    c <- 1    goparkunlock(&sweep.lock, "GC sweep wait", traceEvGoBlock, 1)
    for {        for gosweepone() != ^uintptr(0) {            sweep.nbgsweep++            Gosched()        }        lock(&sweep.lock)        if !gosweepdone() {            // This can happen if a GC runs between            // gosweepone returning ^0 above            // and the lock being acquired.            unlock(&sweep.lock)            continue        }        sweep.parked = true        goparkunlock(&sweep.lock, "GC sweep wait", traceEvGoBlock, 1)    }}
func gosweepone() uintptr {    var ret uintptr    systemstack(func() {        ret = sweepone()    })    return ret}

// sweeps one span// returns number of pages returned to heap, or ^uintptr(0) if there is nothing to sweepfunc sweepone() uintptr {    ...    for {        s := mheap_.sweepSpans[1-sg/2%2].pop()        ...        if !s.sweep(false) {            // Span is still in-use, so this returned no            // pages to the heap and the span needs to            // move to the swept in-use list.            npages = 0        }    }}
// Sweep frees or collects finalizers for blocks not marked in the mark phase.// It clears the mark bits in preparation for the next GC round.// Returns true if the span was returned to heap.// If preserve=true, don't return it to heap nor relink in MCentral lists;// caller takes care of it.func (s *mspan) sweep(preserve bool) bool {    ...}