MemStats 查询度量内存和GC使用

// Alloc is bytes of allocated heap objects.

// 堆空间分配的字节数

// This is the same as HeapAlloc (see below).

Alloc uint64



// TotalAlloc is cumulative bytes allocated for heap objects.

//

// TotalAlloc increases as heap objects are allocated, but

// unlike Alloc and HeapAlloc, it does not decrease when

// objects are freed. 从服务开始运行至今分配器为分配的堆空间总和

TotalAlloc uint64



// Sys is the total bytes of memory obtained from the OS.

//

// Sys is the sum of the XSys fields below. Sys measures the

// virtual address space reserved by the Go runtime for the

// heap, stacks, and other internal data structures. It's

// likely that not all of the virtual address space is backed

// by physical memory at any given moment, though in general

// it all was at some point. 服务现在使用的内存

Sys uint64



// Lookups is the number of pointer lookups performed by the

// runtime.

//

// This is primarily useful for debugging runtime internals. 被runtime监视的指针数

Lookups uint64



// Mallocs is the cumulative count of heap objects allocated. 服务malloc的次数

// The number of live objects is Mallocs - Frees.

Mallocs uint64



// Frees is the cumulative count of heap objects freed. 服务回收的heap objects

Frees uint64



// Heap memory statistics.

//

// Interpreting the heap statistics requires some knowledge of

// how Go organizes memory. Go divides the virtual address

// space of the heap into "spans", which are contiguous

// regions of memory 8K or larger. A span may be in one of

// three states:

//

// An "idle" span contains no objects or other data. The

// physical memory backing an idle span can be released back

// to the OS (but the virtual address space never is), or it

// can be converted into an "in use" or "stack" span.

//

// An "in use" span contains at least one heap object and may

// have free space available to allocate more heap objects.

//

// A "stack" span is used for goroutine stacks. Stack spans

// are not considered part of the heap. A span can change

// between heap and stack memory; it is never used for both

// simultaneously.



// HeapAlloc is bytes of allocated heap objects.

//

// "Allocated" heap objects include all reachable objects, as

// well as unreachable objects that the garbage collector has

// not yet freed. Specifically, HeapAlloc increases as heap

// objects are allocated and decreases as the heap is swept

// and unreachable objects are freed. Sweeping occurs

// incrementally between GC cycles, so these two processes

// occur simultaneously, and as a result HeapAlloc tends to

// change smoothly (in contrast with the sawtooth that is

// typical of stop-the-world garbage collectors).

//服务分配的堆内存

HeapAlloc uint64



// HeapSys is bytes of heap memory obtained from the OS.

//

// HeapSys measures the amount of virtual address space

// reserved for the heap. This includes virtual address space

// that has been reserved but not yet used, which consumes no

// physical memory, but tends to be small, as well as virtual

// address space for which the physical memory has been

// returned to the OS after it became unused (see HeapReleased

// for a measure of the latter).

//

// HeapSys estimates the largest size the heap has had.

//系统分配的堆内存

HeapSys uint64



// HeapIdle is bytes in idle (unused) spans.

//

// Idle spans have no objects in them. These spans could be

// (and may already have been) returned to the OS, or they can

// be reused for heap allocations, or they can be reused as

// stack memory.

//

// HeapIdle minus HeapReleased estimates the amount of memory

// that could be returned to the OS, but is being retained by

// the runtime so it can grow the heap without requesting more

// memory from the OS. If this difference is significantly

// larger than the heap size, it indicates there was a recent

// transient spike in live heap size.

//申请但是为分配的堆内存，（或者回收了的堆内存）

HeapIdle uint64



// HeapInuse is bytes in in-use spans.

//

// In-use spans have at least one object in them. These spans

// can only be used for other objects of roughly the same

// size.

//

// HeapInuse minus HeapAlloc esimates the amount of memory

// that has been dedicated to particular size classes, but is

// not currently being used. This is an upper bound on

// fragmentation, but in general this memory can be reused

// efficiently.

//正在使用的堆内存

HeapInuse uint64



// HeapReleased is bytes of physical memory returned to the OS.

//

// This counts heap memory from idle spans that was returned

// to the OS and has not yet been reacquired for the heap.

//返回给OS的堆内存，类似C/C++中的free。

HeapReleased uint64



// HeapObjects is the number of allocated heap objects.

//

// Like HeapAlloc, this increases as objects are allocated and

// decreases as the heap is swept and unreachable objects are

// freed.

//堆内存块申请的量

HeapObjects uint64



// Stack memory statistics.

//

// Stacks are not considered part of the heap, but the runtime

// can reuse a span of heap memory for stack memory, and

// vice-versa.



// StackInuse is bytes in stack spans.

//

// In-use stack spans have at least one stack in them. These

// spans can only be used for other stacks of the same size.

//

// There is no StackIdle because unused stack spans are

// returned to the heap (and hence counted toward HeapIdle).

//正在使用的栈

StackInuse uint64



// StackSys is bytes of stack memory obtained from the OS.

//

// StackSys is StackInuse, plus any memory obtained directly

// from the OS for OS thread stacks (which should be minimal).

//系统分配的作为运行栈的内存

StackSys uint64



// Off-heap memory statistics.

//

// The following statistics measure runtime-internal

// structures that are not allocated from heap memory (usually

// because they are part of implementing the heap). Unlike

// heap or stack memory, any memory allocated to these

// structures is dedicated to these structures.

//

// These are primarily useful for debugging runtime memory

// overheads.



// MSpanInuse is bytes of allocated mspan structures. 用于测试用的结构体使用的字节数

MSpanInuse uint64



// MSpanSys is bytes of memory obtained from the OS for mspan

// structures. 系统为测试用的结构体分配的字节数

MSpanSys uint64



// MCacheInuse is bytes of allocated mcache structures. mcache结构体申请的字节数

MCacheInuse uint64



// MCacheSys is bytes of memory obtained from the OS for

// mcache structures. 操作系统申请的堆空间用于mcache的量

MCacheSys uint64



// BuckHashSys is bytes of memory in profiling bucket hash tables.用于剖析桶散列表的堆空间

BuckHashSys uint64



// GCSys is bytes of memory in garbage collection metadata. 垃圾回收标记元信息使用的内存

GCSys uint64



// OtherSys is bytes of memory in miscellaneous off-heap

// runtime allocations.  golang系统架构占用的额外空间

OtherSys uint64



// Garbage collector statistics.



// NextGC is the target heap size of the next GC cycle.

//

// The garbage collector's goal is to keep HeapAlloc ≤ NextGC.

// At the end of each GC cycle, the target for the next cycle

// is computed based on the amount of reachable data and the

// value of GOGC. 垃圾回收器检视的内存大小

NextGC uint64



// LastGC is the time the last garbage collection finished, as

// nanoseconds since 1970 (the UNIX epoch).

// 垃圾回收器最后一次执行时间。

LastGC uint64



// PauseTotalNs is the cumulative nanoseconds in GC

// stop-the-world pauses since the program started.

//

// During a stop-the-world pause, all goroutines are paused

// and only the garbage collector can run. 

// 垃圾回收或者其他信息收集导致服务暂停的次数。

PauseTotalNs uint64



// PauseNs is a circular buffer of recent GC stop-the-world

// pause times in nanoseconds.

//

// The most recent pause is at PauseNs[(NumGC+255)%256]. In

// general, PauseNs[N%256] records the time paused in the most

// recent N%256th GC cycle. There may be multiple pauses per

// GC cycle; this is the sum of all pauses during a cycle. 一个循环队列，记录最近垃圾回收系统中断的时间

PauseNs [256]uint64



// PauseEnd is a circular buffer of recent GC pause end times,

// as nanoseconds since 1970 (the UNIX epoch).

//

// This buffer is filled the same way as PauseNs. There may be

// multiple pauses per GC cycle; this records the end of the

// last pause in a cycle. 一个循环队列，记录最近垃圾回收系统中断的时间开始点。

PauseEnd [256]uint64



// NumGC is the number of completed GC cycles.

//垃圾回收的内存大小

NumGC uint32



// NumForcedGC is the number of GC cycles that were forced by

// the application calling the GC function.

//服务调用runtime.GC()强制使用垃圾回收的次数。

NumForcedGC uint32



// GCCPUFraction is the fraction of this program's available

// CPU time used by the GC since the program started.

//

// GCCPUFraction is expressed as a number between 0 and 1,

// where 0 means GC has consumed none of this program's CPU. A

// program's available CPU time is defined as the integral of

// GOMAXPROCS since the program started. That is, if

// GOMAXPROCS is 2 and a program has been running for 10

// seconds, its "available CPU" is 20 seconds. GCCPUFraction

// does not include CPU time used for write barrier activity.

//

// This is the same as the fraction of CPU reported by

// GODEBUG=gctrace=1.

//垃圾回收占用服务CPU工作的时间总和。如果有100个goroutine，垃圾回收的时间为1S,那么久占用了100S

GCCPUFraction float64



// EnableGC indicates that GC is enabled. It is always true,

// even if GOGC=off.

//是否启用GC

EnableGC bool



// DebugGC is currently unused.

DebugGC bool



// BySize reports per-size class allocation statistics.

//

// BySize[N] gives statistics for allocations of size S where

// BySize[N-1].Size < S ≤ BySize[N].Size.

//

// This does not report allocations larger than BySize[60].Size.

//内存分配器使用情况

BySize [61]struct {

    // Size is the maximum byte size of an object in this

    // size class.

    Size uint32



    // Mallocs is the cumulative count of heap objects

    // allocated in this size class. The cumulative bytes

    // of allocation is Size*Mallocs. The number of live

    // objects in this size class is Mallocs - Frees.

    Mallocs uint64



    // Frees is the cumulative count of heap objects freed

    // in this size class.

    Frees uint64

} } runtime.MemStats这个结构体包含的字段比较多，但是大多都很有用，去掉那些注释来看各个属性，会发现各个属性都是很有价值的： 1、Alloc uint64 //golang语言框架堆空间分配的字节数 2、TotalAlloc uint64 //从服务开始运行至今分配器为分配的堆空间总 和，只有增加，释放的时候不减少 3、Sys uint64 //服务现在系统使用的内存 4、Lookups uint64 //被runtime监视的指针数 5、Mallocs uint64 //服务malloc的次数 6、Frees uint64 //服务回收的heap objects的字节数 7、HeapAlloc uint64 //服务分配的堆内存字节数 8、HeapSys uint64 //系统分配的作为运行栈的内存 9、HeapIdle uint64 //申请但是未分配的堆内存或者回收了的堆内存（空闲）字节数 10、HeapInuse uint64 //正在使用的堆内存字节数 10、HeapReleased uint64 //返回给OS的堆内存，类似C/C++中的free。 11、HeapObjects uint64 //堆内存块申请的量 12、StackInuse uint64 //正在使用的栈字节数 13、StackSys uint64 //系统分配的作为运行栈的内存 14、MSpanInuse uint64 //用于测试用的结构体使用的字节数 15、MSpanSys uint64 //系统为测试用的结构体分配的字节数 16、MCacheInuse uint64 //mcache结构体申请的字节数(不会被视为垃圾回收) 17、MCacheSys uint64 //操作系统申请的堆空间用于mcache的字节数 18、BuckHashSys uint64 //用于剖析桶散列表的堆空间 19、GCSys uint64 //垃圾回收标记元信息使用的内存 20、OtherSys uint64 //golang系统架构占用的额外空间 21、NextGC uint64 //垃圾回收器检视的内存大小 22、LastGC uint64 // 垃圾回收器最后一次执行时间。 23、PauseTotalNs uint64 // 垃圾回收或者其他信息收集导致服务暂停的次数。 24、PauseNs [256]uint64 //一个循环队列，记录最近垃圾回收系统中断的时间 25、PauseEnd [256]uint64 //一个循环队列，记录最近垃圾回收系统中断的时间开始点。 26、NumForcedGC uint32 //服务调用runtime.GC()强制使用垃圾回收的次数。 27、GCCPUFraction float64 //垃圾回收占用服务CPU工作的时间总和。如果有100个goroutine，垃圾回收的时间为1S,那么久占用了100S。 28、BySize //内存分配器使用情况 以上是我个人对runtime.MemStats各个属性的理解，有理解错的地方还请发表评论或者联系下我共同探讨一下。

systemstack(func() {

    readmemstats_m(m)

})



startTheWorld() }

// The size of the trailing by_size array differs between

// mstats and MemStats. NumSizeClasses was changed, but we

// cannot change MemStats because of backward compatibility.

memmove(unsafe.Pointer(stats), unsafe.Pointer(&memstats), sizeof_C_MStats)



// memstats.stacks_sys is only memory mapped directly for OS stacks.

// Add in heap-allocated stack memory for user consumption.

stats.StackSys += stats.StackInuse }

fmt.Println("Last GC was:", stats.LastGC)



go ProduceFinalizedGarbage() }

for {

    runtime.GC()

    time.Sleep(30 * time.Second) // Give GC time to run

} }