go语言heap go语言和php 区别

Golang实验性功能SetMaxHeap 固定值GC

简单来说， SetMaxHeap 提供了一种可以设置固定触发阈值的 GC （Garbage Collection垃圾回收）方式

创新互联专注于企业营销型网站、网站重做改版、张家界网站定制设计、自适应品牌网站建设、H5技术、购物商城网站建设、集团公司官网建设、外贸网站制作、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为张家界等各大城市提供网站开发制作服务。

官方源码链接

大量临时对象分配导致的 GC 触发频率过高， GC 后实际存活的对象较少，

或者机器内存较充足，希望使用剩余内存，降低 GC 频率的场景

GC 会 STW （ Stop The World ），对于时延敏感场景，在一个周期内连续触发两轮 GC ，那么 STW 和 GC 占用的 CPU 资源都会造成很大的影响， SetMaxHeap 并不一定是完美的，在某些场景下做了些权衡，官方也在进行相关的实验，当前方案仍没有合入主版本。

先看下如果没有 SetMaxHeap ，对于如上所述的场景的解决方案

这里简单说下 GC 的几个值的含义，可通过 GODEBUG=gctrace=1 获得如下数据

这里只关注 128-132-67 MB 135 MB goal ，

分别为 GC开始时内存使用量 - GC标记完成时内存使用量 - GC标记完成时的存活内存量本轮GC标记完成时的预期内存使用量（上一轮 GC 完成时确定）

引用 GC peace设计文档中的一张图来说明

对应关系如下：

简单说下 GC pacing （信用机制）

GC pacing 有两个目标，

那么当一轮 GC 完成时，如何只根据本轮 GC 存活量去实现这两个小目标呢？

这里实际是根据当前的一些数据或状态去预估 “未来”，所有会存在些误差

首先确定 gc Goal goal = memstats.heap_marked + memstats.heap_marked*uint64(gcpercent)/100

heap_marked 为本轮 GC 存活量， gcpercent 默认为 100 ，可以通过环境变量 GOGC=100 或者 debug.SetGCPercent(100) 来设置

那么默认情况下 goal = 2 * heap_marked

gc_trigger 是与 goal 相关的一个值（ gc_trigger 大约为 goal 的 90% 左右），每轮 GC 标记完成时，会根据 |Ha-Hg| 和实际使用的 cpu 资源动态调整 gc_trigger 与 goal 的差值

goal 与 gc_trigger 的差值即为，为 GC 期间分配的对象所预留的空间

GC pacing 还会预估下一轮 GC 发生时，需要扫描对象对象的总量，进而换算为下一轮 GC 所需的工作量，进而计算出 mark assist 的值

本轮 GC 触发（ gc_trigger ），到本轮的 goal 期间，需要尽力完成 GC mark 标记操作，所以当 GC 期间，某个 goroutine 分配大量内存时，就会被拉去做 mark assist 工作，先进行 GC mark 标记赚取足够的信用值后，才能分配对应大小的对象

根据本轮 GC 存活的内存量（ heap_marked ）和下一轮 GC 触发的阈值（ gc_trigger ）计算 sweep assist 的值，本轮 GC 完成，到下一轮 GC 触发（ gc_trigger ）时，需要尽力完成 sweep 清扫操作

预估下一轮 GC 所需的工作量的方式如下：

继续分析文章开头的问题，如何充分利用剩余内存，降低 GC 频率和 GC 对 CPU 的资源消耗

如上图可以看出， GC 后，存活的对象为 2GB 左右，如果将 gcpercent 设置为 400 ，那么就可以将下一轮 GC 触发阈值提升到 10GB 左右

前面一轮看起来很好，提升了 GC 触发的阈值到 10GB ，但是如果某一轮 GC 后的存活对象到达 2.5GB 的时候，那么下一轮 GC 触发的阈值，将会超过内存阈值，造成 OOM （ Out of Memory ），进而导致程序崩溃。

可以通过 GOGC=off 或者 debug.SetGCPercent(-1) 来关闭 GC

可以通过进程外监控内存使用状态，使用信号触发的方式通知程序，或 ReadMemStats 、或 linkname runtime.heapRetained 等方式进行堆内存使用的监测

可以通过调用 runtime.GC() 或者 debug.FreeOSMemory() 来手动进行 GC 。

这里还需要说几个事情来解释这个方案所存在的问题

通过 GOGC=off 或者 debug.SetGCPercent(-1) 是如何关闭 GC 的？

gc 4 @1.006s 0%: 0.033+5.6+0.024 ms clock, 0.27+4.4/11/25+0.19 ms cpu, 428-428-16 MB, 17592186044415 MB goal, 8 P (forced)

通过 GC trace 可以看出，上面所说的 goal 变成了一个很诡异的值 17592186044415

实际上关闭 GC 后， Go 会将 goal 设置为一个极大值 ^uint64(0) ，那么对应的 GC 触发阈值也被调成了一个极大值，这种处理方式看起来也没什么问题，将阈值调大，预期永远不会再触发 GC

那么如果在关闭 GC 的情况下，手动调用 runtime.GC() 会导致什么呢？

由于 goal 和 gc_trigger 被设置成了极大值， mark assist 和 sweep assist 也会按照这个错误的值去计算，导致工作量预估错误，这一点可以从 trace 中进行证明

可以看到很诡异的 trace 图，这里不做深究，该方案与 GC pacing 信用机制不兼容

记住，不要在关闭 GC 的情况下手动触发 GC ，至少在当前 Go1.14 版本中仍存在这个问题

SetMaxHeap 的实现原理，简单来说是强行控制了 goal 的值

注： SetMaxHeap ，本质上是一个软限制，并不能解决极端场景下的 OOM ，可以配合内存监控和 debug.FreeOSMemory() 使用

SetMaxHeap 控制的是堆内存大小， Go 中除了堆内存还分配了如下内存，所以实际使用过程中，与实际硬件内存阈值之间需要留有一部分余量。

对于文章开始所述问题，使用 SetMaxHeap 后，预期的 GC 过程大概是这个样子

简单用法1

该方法简单粗暴，直接将 goal 设置为了固定值

注：通过上文所讲，触发 GC 实际上是 gc_trigger ，所以当阈值设置为 12GB 时，会提前一点触发 GC ，这里为了描述方便，近似认为 gc_trigger=goal

简单用法2

当不关闭 GC 时， SetMaxHeap 的逻辑是， goal 仍按照 gcpercent 进行计算，当 goal 小于 SetMaxHeap 阈值时不进行处理；当 goal 大于 SetMaxHeap 阈值时，将 goal 限制为 SetMaxHeap 阈值

注：通过上文所讲，触发 GC 实际上是 gc_trigger ，所以当阈值设置为 12GB 时，会提前一点触发 GC ，这里为了描述方便，近似认为 gc_trigger=goal

切换到 go1.14 分支，作者选择了 git checkout go1.14.5

选择官方提供的 cherry-pick 方式(可能需要梯子，文件改动不多，我后面会列出具体改动)

git fetch "" refs/changes/67/227767/3 git cherry-pick FETCH_HEAD

需要重新编译Go源码

注意点：

下面源码中的官方注释说的比较清楚，在一些关键位置加入了中文注释

入参bytes为要设置的阈值

notify 简单理解为 GC 的策略发生变化时会向 channel 发送通知，后续源码可以看出“策略”具体指哪些内容

返回值为本次设置之前的 MaxHeap 值

$GOROOT/src/runtime/debug/garbage.go

$GOROOT/src/runtime/mgc.go

注：作者尽量用通俗易懂的语言去解释 Go 的一些机制和 SetMaxHeap 功能，可能有些描述与实现细节不完全一致，如有错误还请指出

Go 语言中如何使用堆 Heap

Go 提供了 container/heap 这个包来实现堆的操作。堆实际上是一个树的结构，每个元素的值都是它的子树中最小的，因此根节点 index = 0 的值是最小的，即最小堆。

堆也是实现优先队列 Priority Queue 的常用方式。

堆中元素的类型需要实现 heap.Interface 这个接口：

其中 sort.Interface 包括 Len() , Less , Swap 方法：

一个完整的示例如下：

注意注释中的一句话 Push 和 Pop 方法需要使用指针，因为它们会修改 slice 的长度，而不仅仅只内容。

Leetcode 692. Top K Frequent Words 也可以使用 Go 语言通过构造 PriorityQueue 来实现：

Golang的pprof的使用心得（CPU，Heap）

参照的是这个文章

首先自己写一段demo

里面负责2件事

doSomeThingOne

genSomeBytes

运行这个程序go run main.go

To install thewrk,you need only:

git clone

cd wrk

make

wrk relies on the openssl and luajit, learn more from its github page

Generating requests

Our demo is listening on the port 9876 ,so let's generate some requests for that.

./wrk -c400 -t8 -d5m

-c400means we have 400 connections to keep open

-t8means we use 8 threads to build requests

-d5mmeans the duration of the test will last for 5 minutes

用这段命令来压服务器

Our server is very busy now and we can see some information via browser. Inputlocalhost:9876/debug/pprofyou will see:

然后用命令进入

在这里能看见各种方法的运行时间

所以我们安装Graphviz 在mac下

brew install graphviz

之后再这个(pprof)里面输入web

会生产一个svg文件

用浏览器打开我们就会看到

很显然gensomebytes里面的math方法最消耗时间。这个就是我们优化的对象

其实也很方便在

localhost:9876/debug/pprof/profile改成

localhost:9876/debug/pprof/heap

后面的结果一样。。和cpu一样可以看到那个heap占用了大量的内存到时候优化吧

这个文章里面的第一个方法就可以做测试内存占用的.

有空试试把

分布式程序 A B C D 4个进程在服务器. 监控程序E 打包程序F

写一个监控程序定时监控这4个进程的CPU 内存(搞成配置文件)

达到性能瓶颈（例如 90%CPU 内存剩下10%） E用shell触发打包程序F把pprof等信息打包.并发送邮件

给配置者.

container之heap

go 的 heap 实现了堆，关于堆可以看下数据结构：堆（Heap），这里就不阐述了，go实现的源码在 container/heap/heap.go 中，其中包含了1个接口，5个外部方法和2个内部方法

也就是说，要使用 heap ，需要自己实现 heap.Interface 接口，并不是开箱即用的，除了 Less 方法，其他的都能根据方法名推出功能， Less 方法返回 bool 类型，典型的实现就是两个元素的比较，通过更改比较规则，我们可以很方便的实现最大堆和最小堆

down 和 up ，根据自定义的 Less 和 Swap 方法进行比较和调换，一个实现向下追溯，一个实现向上追溯，最终目的是为了保证每一个父节点、左子节点和右子节点的三元组满足父节点 =/= min/max(左子节点，右子节点)

源码分析的差不多了，下面来看下应用

heap 个人感觉是一个工具类的半成品吧，做不到开箱即用，而且使用者需要对 heap 的实现比较了解，否则可能容易踩坑，比如上面说到的， heap 中 Pop 方法默认弹出末位元素， Less 方法如何实现才能控制最大/小堆等等，而且使用其他方法之前必须先调用 Init 方法，否则结果可能是非预期的，这点 heap 里面也没有进行限制，最后建议如果使用heap，最好跟上面例子一样使用slice进行包装，这样接入的成本是最低的

Go 语言内存管理（三）：逃逸分析

Go 语言较之 C 语言一个很大的优势就是自带 GC 功能，可 GC 并不是没有代价的。写 C 语言的时候，在一个函数内声明的变量，在函数退出后会自动释放掉，因为这些变量分配在栈上。如果你期望变量的数据可以在函数退出后仍然能被访问，就需要调用 malloc 方法在堆上申请内存，如果程序不再需要这块内存了，再调用 free 方法释放掉。Go 语言不需要你主动调用 malloc 来分配堆空间，编译器会自动分析，找出需要 malloc 的变量，使用堆内存。编译器的这个分析过程就叫做逃逸分析。

所以你在一个函数中通过 dict := make(map[string]int) 创建一个 map 变量，其背后的数据是放在栈空间上还是堆空间上，是不一定的。这要看编译器分析的结果。

可逃逸分析并不是百分百准确的，它有缺陷。有的时候你会发现有些变量其实在栈空间上分配完全没问题的，但编译后程序还是把这些数据放在了堆上。如果你了解 Go 语言编译器逃逸分析的机制，在写代码的时候就可以有意识地绕开这些缺陷，使你的程序更高效。

Go 语言虽然在内存管理方面降低了编程门槛，即使你不了解堆栈也能正常开发，但如果你要在性能上较真的话，还是要掌握这些基础知识。

这里不对堆内存和栈内存的区别做太多阐述。简单来说就是，栈分配廉价，堆分配昂贵。栈空间会随着一个函数的结束自动释放，堆空间需要时间 GC 模块不断地跟踪扫描回收。如果对这两个概念有些迷糊，建议阅读下面 2 个文章：

这里举一个小例子，来对比下堆栈的差别：

stack 函数中的变量 i 在函数退出会自动释放；而 heap 函数返回的是对变量 i 的引用，也就是说 heap() 退出后，表示变量 i 还要能被访问，它会自动被分配到堆空间上。

他们编译出来的代码如下：

逻辑的复杂度不言而喻，从上面的汇编中可看到， heap() 函数调用了 runtime.newobject() 方法，它会调用 mallocgc 方法从 mcache 上申请内存，申请的内部逻辑前面文章已经讲述过。堆内存分配不仅分配上逻辑比栈空间分配复杂，它最致命的是会带来很大的管理成本，Go 语言要消耗很多的计算资源对其进行标记回收（也就是 GC 成本）。

Go 编辑器会自动帮我们找出需要进行动态分配的变量，它是在编译时追踪一个变量的生命周期，如果能确认一个数据只在函数空间内访问，不会被外部使用，则使用栈空间，否则就要使用堆空间。

我们在 go build 编译代码时，可使用 -gcflags '-m' 参数来查看逃逸分析日志。

以上面的两个函数为例，编译的日志输出是：

日志中的 i escapes to heap 表示该变量数据逃逸到了堆上。

需要使用堆空间，所以逃逸，这没什么可争议的。但编译器有时会将不需要使用堆空间的变量，也逃逸掉。这里是容易出现性能问题的大坑。网上有很多相关文章，列举了一些导致逃逸情况，其实总结起来就一句话：

多级间接赋值容易导致逃逸。

这里的多级间接指的是，对某个引用类对象中的引用类成员进行赋值。Go 语言中的引用类数据类型有 func , interface , slice , map , chan , *Type(指针) 。

记住公式 Data.Field = Value ，如果 Data , Field 都是引用类的数据类型，则会导致 Value 逃逸。这里的等号 = 不单单只赋值，也表示参数传递。

根据公式，我们假设一个变量 data 是以下几种类型，相应的可以得出结论：

下面给出一些实际的例子：

如果变量值是一个函数，函数的参数又是引用类型，则传递给它的参数都会逃逸。

上例中 te 的类型是 func(*int) ，属于引用类型，参数 *int 也是引用类型，则调用 te(j) 形成了为 te 的参数(成员) *int 赋值的现象，即 te.i = j 会导致逃逸。代码中其他几种调用都没有形成多级间接赋值情况。

同理，如果函数的参数类型是 slice , map 或 interface{} 都会导致参数逃逸。

匿名函数的调用也是一样的，它本质上也是一个函数变量。有兴趣的可以自己测试一下。

只要使用了 Interface 类型(不是 interafce{} )，那么赋值给它的变量一定会逃逸。因为 interfaceVariable.Method() 先是间接的定位到它的实际值，再调用实际值的同名方法，执行时实际值作为参数传递给方法。相当于 interfaceVariable.Method.this = realValue

向 channel 中发送数据，本质上就是为 channel 内部的成员赋值，就像给一个 slice 中的某一项赋值一样。所以 chan *Type , chan map[Type]Type , chan []Type , chan interface{} 类型都会导致发送到 channel 中的数据逃逸。

这本来也是情理之中的，发送给 channel 的数据是要与其他函数分享的，为了保证发送过去的指针依然可用，只能使用堆分配。

可变参数如 func(arg ...string) 实际与 func(arg []string) 是一样的，会增加一层访问路径。这也是 fmt.Sprintf 总是会使参数逃逸的原因。

例子非常多，这里不能一一列举，我们只需要记住分析方法就好，即，2 级或更多级的访问赋值会容易导致数据逃逸。这里加上容易二字是因为随着语言的发展，相信这些问题会被慢慢解决，但现阶段，这个可以作为我们分析逃逸现象的依据。

下面代码中包含 2 种很常规的写法，但他们却有着很大的性能差距，建议自己想下为什么。

Benchmark 和 pprof 给出的结果:

熟悉堆栈概念可以让我们更容易看透 Go 程序的性能问题，并进行优化。

多级间接赋值会导致 Go 编译器出现不必要的逃逸，在一些情况下可能我们只需要修改一下数据结构就会使性能有大幅提升。这也是很多人不推荐在 Go 中使用指针的原因，因为它会增加一级访问路径，而 map , slice , interface{} 等类型是不可避免要用到的，为了减少不必要的逃逸，只能拿指针开刀了。

大多数情况下，性能优化都会为程序带来一定的复杂度。建议实际项目中还是怎么方便怎么写，功能完成后通过性能分析找到瓶颈所在，再对局部进行优化。

【golang详解】go语言GMP(GPM)原理和调度

Goroutine调度是一个很复杂的机制，下面尝试用简单的语言描述一下Goroutine调度机制，想要对其有更深入的了解可以去研读一下源码。

首先介绍一下GMP什么意思：

G ----------- goroutine: 即Go协程，每个go关键字都会创建一个协程。

M ---------- thread内核级线程，所有的G都要放在M上才能运行。

P ----------- processor处理器，调度G到M上，其维护了一个队列，存储了所有需要它来调度的G。

Goroutine 调度器P和 OS 调度器是通过 M 结合起来的，每个 M 都代表了 1 个内核线程，OS 调度器负责把内核线程分配到 CPU 的核上执行

模型图：

避免频繁的创建、销毁线程，而是对线程的复用。

1）work stealing机制

当本线程无可运行的G时，尝试从其他线程绑定的P偷取G，而不是销毁线程。

2）hand off机制

当本线程M0因为G0进行系统调用阻塞时，线程释放绑定的P，把P转移给其他空闲的线程执行。进而某个空闲的M1获取P，继续执行P队列中剩下的G。而M0由于陷入系统调用而进被阻塞，M1接替M0的工作，只要P不空闲，就可以保证充分利用CPU。M1的来源有可能是M的缓存池，也可能是新建的。当G0系统调用结束后，根据M0是否能获取到P，将会将G0做不同的处理：

如果有空闲的P，则获取一个P，继续执行G0。

如果没有空闲的P，则将G0放入全局队列，等待被其他的P调度。然后M0将进入缓存池睡眠。

如下图

GOMAXPROCS设置P的数量，最多有GOMAXPROCS个线程分布在多个CPU上同时运行

在Go中一个goroutine最多占用CPU 10ms，防止其他goroutine被饿死。

具体可以去看另一篇文章

【Golang详解】go语言调度机制抢占式调度

当创建一个新的G之后优先加入本地队列，如果本地队列满了，会将本地队列的G移动到全局队列里面，当M执行work stealing从其他P偷不到G时，它可以从全局G队列获取G。

协程经历过程

我们创建一个协程 go func()经历过程如下图：

说明：

这里有两个存储G的队列，一个是局部调度器P的本地队列、一个是全局G队列。新创建的G会先保存在P的本地队列中，如果P的本地队列已经满了就会保存在全局的队列中；处理器本地队列是一个使用数组构成的环形链表，它最多可以存储 256 个待执行任务。

G只能运行在M中，一个M必须持有一个P，M与P是1：1的关系。M会从P的本地队列弹出一个可执行状态的G来执行，如果P的本地队列为空，就会想其他的MP组合偷取一个可执行的G来执行；

一个M调度G执行的过程是一个循环机制；会一直从本地队列或全局队列中获取G

上面说到P的个数默认等于CPU核数，每个M必须持有一个P才可以执行G，一般情况下M的个数会略大于P的个数，这多出来的M将会在G产生系统调用时发挥作用。类似线程池，Go也提供一个M的池子，需要时从池子中获取，用完放回池子，不够用时就再创建一个。

work-stealing调度算法：当M执行完了当前P的本地队列队列里的所有G后，P也不会就这么在那躺尸啥都不干，它会先尝试从全局队列队列寻找G来执行，如果全局队列为空，它会随机挑选另外一个P，从它的队列里中拿走一半的G到自己的队列中执行。

如果一切正常，调度器会以上述的那种方式顺畅地运行，但这个世界没这么美好，总有意外发生，以下分析goroutine在两种例外情况下的行为。

Go runtime会在下面的goroutine被阻塞的情况下运行另外一个goroutine：

用户态阻塞/唤醒

当goroutine因为channel操作或者network I/O而阻塞时（实际上golang已经用netpoller实现了goroutine网络I/O阻塞不会导致M被阻塞，仅阻塞G，这里仅仅是举个栗子），对应的G会被放置到某个wait队列(如channel的waitq)，该G的状态由_Gruning变为_Gwaitting，而M会跳过该G尝试获取并执行下一个G，如果此时没有可运行的G供M运行，那么M将解绑P，并进入sleep状态；当阻塞的G被另一端的G2唤醒时（比如channel的可读/写通知），G被标记为，尝试加入G2所在P的runnext（runnext是线程下一个需要执行的 Goroutine。），然后再是P的本地队列和全局队列。

系统调用阻塞

当M执行某一个G时候如果发生了阻塞操作，M会阻塞，如果当前有一些G在执行，调度器会把这个线程M从P中摘除，然后再创建一个新的操作系统的线程(如果有空闲的线程可用就复用空闲线程)来服务于这个P。当M系统调用结束时候，这个G会尝试获取一个空闲的P执行，并放入到这个P的本地队列。如果获取不到P，那么这个线程M变成休眠状态，加入到空闲线程中，然后这个G会被放入全局队列中。

队列轮转

可见每个P维护着一个包含G的队列，不考虑G进入系统调用或IO操作的情况下，P周期性的将G调度到M中执行，执行一小段时间，将上下文保存下来，然后将G放到队列尾部，然后从队列中重新取出一个G进行调度。

除了每个P维护的G队列以外，还有一个全局的队列，每个P会周期性地查看全局队列中是否有G待运行并将其调度到M中执行，全局队列中G的来源，主要有从系统调用中恢复的G。之所以P会周期性地查看全局队列，也是为了防止全局队列中的G被饿死。

M0是启动程序后的编号为0的主线程，这个M对应的实例会在全局变量rutime.m0中，不需要在heap上分配，M0负责执行初始化操作和启动第一个G，在之后M0就和其他的M一样了

G0是每次启动一个M都会第一个创建的goroutine，G0仅用于负责调度G，G0不指向任何可执行的函数，每个M都会有一个自己的G0，在调度或系统调用时会使用G0的栈空间，全局变量的G0是M0的G0

一个G由于调度被中断，此后如何恢复？

中断的时候将寄存器里的栈信息，保存到自己的G对象里面。当再次轮到自己执行时，将自己保存的栈信息复制到寄存器里面，这样就接着上次之后运行了。

我这里只是根据自己的理解进行了简单的介绍，想要详细了解有关GMP的底层原理可以去看Go调度器 G-P-M 模型的设计者的文档或直接看源码

参考： ()

()

本文名称：go语言heap go语言和php 区别
转载源于：http://ybzwz.com/article/hgepjg.html