GOGC

最新推荐文章于 2024-05-28 10:58:16 发布
最新推荐文章于 2024-05-28 10:58:16 发布
阅读量1.3k 收藏 9
点赞数 1
分类专栏： Go 文章标签： go 垃圾回收
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40242845/article/details/114744783
版权

Go GC

本文档主要记录自己对Go GC的一些学习笔记，以及学习逻辑，参考资料在文末的资料来源。

本文档将会学到

  • 什么是GC，GC是来干嘛的，为了什么
  • 谁现在在用GC
  • 区分GC好坏的指标是什么
  • GC通常有什么算法
  • GC在什么时候触发
  • GO使用了什么GC算法，演变是怎样的
  • GO中GC执行的流程是怎样的
  • GO GC相关API
  • 如何观察GC
  • GC如何调优

什么是GC

Garbage Collection

GC，Garbage Collection的缩写，自动内存管理机制。程序创建对象等引用类型实体时会在虚拟内存中分配给它们一块内存空间，如果该内存空间不再被任何引用变量引用时就成为需要被回收的垃圾。

垃圾回收器组件

垃圾回收器分为两个半独立的组件

  • 赋值器 Mutator：对用户态对象图进行操作(上色)
  • 回收器 Collector：负责执行垃圾回收(回收)

用户程序Mutator通过内存分配器Allocator在堆Heap上申请内存，垃圾回收器Collector会定时清理堆上的内存。

在这里插入图片描述

垃圾回收器的目标
  • 无内存泄漏：垃圾回收器最基本的目标就是减少防止程序员未及时释放导致的内存泄漏，垃圾回收器会识别并清理内存中的垃圾
  • 自动回收无用内存：垃圾回收器作为独立的子任务，不需要程序员显式调用即可自动清理内存垃圾
  • 内存整理：如果只是简单回收无用内存，那么堆上的内存空间会存在较多碎片而无法满足分配较大对象的需求，因此垃圾回收器需要重整内存空间，提高内存利用率

谁在用GC

从原理上而言，所有的语言都能够自行实现 GC。从语言诞生之初就提供 GC 的语言，例如：

  • Python
  • JavaScript
  • Java
  • Objective-C
  • Swift

而不以 GC 为目标，被直接设计为手动管理内存、但可以自行实现 GC 的语言有：

  • C
  • C++

也有一些语言可以在编译期，依靠编译器插入清理代码的方式，实现精准的清理，例如：

  • Rust

垃圾回收使程序员无需手动处理内存释放，从而能够消除一些需要手动管理内存才会出现的运行时错误：

  1. 在仍然有指向内存区块的指针的情况下释放这块内存时，会产生悬挂指针，从而后续可能错误的访问已经用于他用的内存区域。
  2. 多重释放同一块申请的内存区域可能导致不可知的内存损坏。

当然，垃圾回收也会伴随一些缺陷，这也就造就了没有 GC 的一些优势：

  1. 没有额外的性能开销
  2. 精准的手动内存管理，极致的利用机器的性能

GC指标

  • CPU利用率：回收程序会占程序多少CPU来执行从而拖慢程序
  • GC停顿时间：回收器占用多长时间
  • GC停顿频率：回收器停顿频率为何
  • GC可扩展性：当堆内存变大时，垃圾回收器性能如何

常见GC算法

常见GC分为两大类：

  • 追踪(tracing)：从根对象出发，根据对象之间的引用信息，扫描，直到确定要保留的对象，回收无引用对象。一般是GO，JAVA，V8等
  • 引用计数式：每个对象自身包含一个计数器，当计数器归零的自动回收。一般是Python，object-C等
追踪式
标记清扫

标记-清除算法将垃圾回收分为两个阶段：标记阶段和清除阶段。一种可行的实现是，在标记阶段，首先通过根节点，标记所有从根节点开始的可达对象。因此，未被标记的对象就是未被引用的垃圾对象。然后，在清除阶段，清除所有未被标记的对象。这也是GO在GC算法的基础。

在这里插入图片描述

标记清扫优点：

  • 可以解决循环调用问题

标记清扫缺点：

  • 效率较慢，因为在标记和清除时都要遍历所有的对象，并且在每次GC开始的时候都要STW
  • 因为内存分配时的碎片化，导致在回收之后也会有不同程度的碎片化，导致内存利用率不高
标记压缩

它在标记-清除算法的基础上做了一些优化。和标记-清除算法一样，标记-压缩算法也首先需要从根节点开始，对所有可达对象做一次标记。但之后，它并不简单的清理未标记的对象，而是将所有的存活对象压缩到内存的一端。之后，清理边界外所有的空间。

在这里插入图片描述

标记压缩优点：

  • 标记-压缩算法适合用于存活对象较多的场合，如老年代

  • 降低堆内存碎片化问题

标记压缩缺点：

  • 效率相较标记清扫更低了
标记复制

将原有的内存空间分为两块，每次只使用其中一块，在垃圾回收时，将正在使用的内存中的存活对象复制到未使用的内存块中，之后，清除正在使用的内存块中的所有对象，交换两个内存的角色，完成垃圾回收。

在这里插入图片描述

标记复制优点：

  • 与标记-清除算法相比，复制算法是一种相对高效的回收方法（默认应用于青年代）

  • 效率较高

标记复制缺点：

  • 浪费空间
  • 对可达对象存活周期长的效率不高
分代式

对于一个大型的系统，当创建的对象和方法变量比较多时，堆内存中的对象也会比较多，如果逐一分析对象是否该回收，那么势必造成效率低下。分代收集算法是基于这样一个事实：不同的对象的生命周期(存活情况)是不一样的，而不同生命周期的对象位于堆中不同的区域，因此对堆内存不同区域采用不同的策略进行回收可以提高 JVM 的执行效率。当代商用虚拟机使用的都是分代收集算法：新生代对象存活率低，就采用复制算法；老年代存活率高，就用标记清除算法或者标记整理算法。Java堆内存一般可以分为新生代、老年代和永久代三个模块。

根据不同对象的存活周期分为不同的几块

  • 老年代：标记清扫 或 标记整理
  • 青年代：标记复制
引用计数法

引用计数Reference counting会为每个对象维护一个计数器，当该对象被其他对象引用时加一，引用失效时减一，当引用次数归零后即可回收对象。使用这类GC方法的语言包括python、php、objective-C和C++标准库中的std::shared_ptr等。

以python为例，python中的每个对象都包含如下结构：

typedef struct_object {
    int ob_refcnt;
    struct_typeobject *ob_type;
}PyObject;

其中ob_refcnt为引用计数器，当一个对象有新的引用时计数器增一，当引用它的对象被删除时计数器减一。

引用计数法优点包括：

  • 原理和实现都比较简单
  • 回收的即时性：当对象的引用计数为0时立即回收，不像其他GC机制需要等待特定时机再回收，提高了内存的利用率
  • 不需要暂停应用即可完成回收

缺点包括：

  • 无法解决循环引用的回收问题：当ObjA引用了ObjB，ObjB也引用ObjA时，这两个对象的引用次数使用大于0，从而占用的内存无法被回收
  • 时间和空间成本较高：一方面是因为每个对象需要额外的空间存储引用计数器变量，另一方面是在栈上的赋值时修改引用次数时间成本较高（原本只需要修改寄存器中的值，现在计数器需要不断更新因此不是只读的，需要额外的原子操作来保证线程安全）
  • 引用计数是一种摊销算法，会将内存的回收分摊到整个程序的运行过程，但是当销毁一个很大的树形结构时无法保证响应时间

GC触发机制

主要分为主动触发和被动触发

  • 主动触发：runtime GC，阻塞式等待当前GC调用完成
  • 被动触发：
    • 系统监控，超过2分钟没有引用就强制GC
    • 步调(Pacing算法)，控制内存增长的比例

GO使用的GC算法

无分代、不整理、并发的三色标记法

对象整理目的：

  1. 是解决内存碎片问题，但是Go给予tcmalloc分配算法，基本没有碎片问题。
    另外顺序内存分配器在多线程并不适用，整理内存队tcmalloc分配没有实质提升
  2. 分代GC目标主要是针对新创建对象，不会频繁检查所有对象。但是Go会通过逃逸分析将大部分“新生”对象存储在栈上，需要长期保存的对象存在于堆中。栈会被回收，不需要GC。
    Go的GC更专注于如何让GC和用户代码并发执行
GO 1.3 mark and sweep

mark and sweep分为2个步骤

  • 暂停业务逻辑(需要STW)，找到不可达对象并标记
  • 回收标记好的对象

在这里插入图片描述
在这里插入图片描述

可以看到一次GC里面需要一次STW，在没有优化之前，STW的时间是比较久的。只有到清扫完成之后才停止STW，因此GO 1.3进行了一个优化，就是讲停止STW改到清扫之前。

在这里插入图片描述

GO 1.5 三色并发标记法
哪三色？
  • 白色对象：程序生成的对象都是白色对象，GC结束后还是白色的会被回收
  • 灰色对象：可达对象，在GC遍历时遍历到的对象，GC结束后不会回收，正常是变为黑色
  • 黑色对象：保留对象，在灰色遍历完之后，或者无接下去可达对象的灰色对象，最后都变为灰色对象
步骤

步骤一、将程序以根节点展开

步骤二、所有对象放入白色集合

步骤三、根节点开始遍历，遍历到的标为灰色

步骤四、遍历灰色，将遍历到的放入灰色，原本灰色的放入黑色

步骤五、重复上一步直到无灰色对象

步骤六、回收白色对象

基于标记清扫的例子，看一下三色并发标记法是如何实现的，记住GC开始时还是需要STW

根据步骤一，将会变成如下：

将程序以根节点展开

在这里插入图片描述

根据步骤二，我们会建立白色对象，灰色对象和黑色对象集合。首先的是将所有对象先放到白色对象，最后剩下的白色对象，也就是要回收的对象。

在这里插入图片描述

步骤三，遍历白色对象内的根对象，也就是对象1(dx1)和对象4。将遍历到的对象，由白色标记为灰色。

在这里插入图片描述

步骤四，遍历灰色，将遍历到的放入灰色，原本灰色的放入黑色。以对象1为例，对象2会从白色标机为灰色，而对象1会被标记为黑色。

在这里插入图片描述

步骤五，循环第四步，直到没有灰色对象为止。

在这里插入图片描述

步骤六，当没有灰色对象后，回收白色对象

在这里插入图片描述

为何在GC一开始需要STW

看下图，要扫描对象2的时候。对象2删除对对象6的引用，同时，对象4创建指针指向对象6。此时继续标记，因为对象4不会再被扫描，所以，对象6会被当做回收对象。到最后就是，对象4指向的对象6会被清扫。因此，在没有STW的时候会发生如下两种情况：

  • 白对象被黑引用
  • 灰对象与可达对象失去关系

在这里插入图片描述

可见，其实STW是为了保护在程序执行过程中，由于额外的新增或删除导致不可控的对象丢失的一个做法。因为STW是需要暂定整个程序，所以STW的时间成为了一个指标，也上升为GC算法的一直指标，也是后面GC算法优化的一个点。

因此提出2个概念用于防止上述情况发生：

  • 强三色不变式：不允许黑色对象引用白色对象
  • 弱三色不变式：所有黑色对象引用的白色对象都必须在灰色对象保护链下

在这里插入图片描述

插入屏障

强三色不变式: 黑色引用白色对象后，白色对象变为灰色对象

如下图例子，遍历完对象1和对象4之后，分别引用对象7和对象8。根据插入屏障强三式，此时对象8会标记为灰色，再下个循环标记的时候，对象8可以标记为黑色保留下来。

在这里插入图片描述

可以看到对象7其实是没有像对象8一样，立马被标记为灰色。这是因为，栈容量小，反应速度要求高，不能用插入屏障的机制。因此，在堆对象扫描完之后，会对栈对象STW，然后通过三色并发标记清扫，完成GC。即，此例中的对象7得以保留。

在这里插入图片描述

删除屏障

弱三色不变式：被删除对象为灰色或白色，则标记为灰色对象

如下，为了保证对象没有被误扫除，在扫描对象1和对象4时，对象1删除对对象2的指向后。根据删除屏障弱三式，对象2会被标记为灰色。按照三色并发标记，最终GC如下右侧图。不过可以看到，虽然在一定程度上降低了对象被误扫除的机率，但同时降低了GC的精度。例如对象2和对线6就需要在下次GC的时候才会销毁。
在这里插入图片描述

GO 1.8混合写屏障

可以看到之前的插入屏障和删除屏障有明显的自身缺陷：

  • 插入屏障：需要对栈对象重新STW遍历
  • 删除屏障：回收精度低

混合写屏障，就是结合两者优势，又中和两者的劣势。混合写屏障减少STW，并且减少了扫描栈对象的时间。混合写屏障会做如下操作：

  • GC开始时，将栈全部标记为黑色
  • GC期间，任何创建在栈上的对象都标记为黑色
  • 被删除的对象标记为灰色
  • 被添加的对象标记为灰色
栈对象引用堆对象

遍历对象4时，删除对对象5的引用，对象1创建对对象5的引用，对象5被标记为灰色。

在这里插入图片描述

某个栈对象引用另一个栈对象的引用

在栈上创建对象7，对象7会被标记为黑色。同时，对象7创建对对象6的引用，对象2删除对对象6的引用。由于都在栈上操作，因此没有标记色动作。

在这里插入图片描述

某个堆对象引用另一个堆对象的引用

遍历对象4时，删除对对象5的引用。同时，对象7创建对对象5的引用。对象5被标记为灰色，避免被错误回收。

在这里插入图片描述

堆对象引用栈对象

遍历对象4时，删除对对象5的引用。同时，对象4创建对对象2的引用。对象5会被标记为灰色，为了保证下游对象不被误回收。

在这里插入图片描述

GO GC流程

Go GC对应5个流程分别是：

GC Mark Prepare

标记准备阶段，为并发标记做准备工作，包括开启写屏障(write barrier)和辅助GC(mutator assist)，统计root对象的任务数量等 --> STW

GC Mark

扫描标记阶段，扫描所有root对象，包括全局指针和goroutine(G)栈上的指针（扫描对应G栈时需停止该G)，将其加入标记队列(灰色队列)，并循环处理灰色队列的对象，直到灰色队列为空 --> 后台并发

GC Mark Termination

标记终止阶段，保证一个周期内标记任务完成，停止写屏障。同时由于Mark和用户代码是并发执行，所以需要重新扫描(re-scan)全局指针和栈。 --> STW

GC Off SWEEP

内存清扫阶段，将需要回收的内存归还到堆中，写屏障关闭 --> 后台并发

GCoff

内存归还阶段，将过多的内存归还给操作系统，写屏障关闭 --> 后台并发

GO GC API

  • runtime.GC：手动触发GC
  • runtime.ReadMemStats：读取内存相关的统计信息，其中包含部分GC相关的统计信息
  • debug.FreeOSMemory：手动将内存归还给操作系统
  • debug.ReadGCStats：读取关于GC的相关统计信息
  • debug.SetGCPercent：设置GOGC调步变量
  • debug.SetMaxHeap：设置GO程序堆的上限值

观察GC

下面通过此代码尝试观察gc

package main

func allocate() {
	_ = make([]byte, 1<<20)
}

func main() {
	for n := 1; n < 100000; n++ {
		allocate()
	}
}
GODEBUG=gctrace=1

通过GODEBUG=gctrace=1这个参数来观察gc的情况

GODEBUG=gctrace=1 ./main

执行后部分结果如下

gc 1 @0.000s 0%: 0.007+0.22+0.002 ms clock, 0.042+0.059/0.051/0.009+0.015 ms cpu, 4->7->3 MB, 5 MB goal, 6 P
gc 2 @0.001s 3%: 0.023+0.29+0.10 ms clock, 0.13+0.043/0.021/0+0.61 ms cpu, 5->6->1 MB, 6 MB goal, 6 P
gc 3 @0.001s 4%: 0.062+0.41+0.003 ms clock, 0.37+0.041/0.17/0.018+0.018 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 4 @0.002s 4%: 0.025+0.22+0.002 ms clock, 0.15+0.046/0.018/0.001+0.013 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 5 @0.003s 4%: 0.008+0.38+0.002 ms clock, 0.051+0.053/0.097/0.016+0.017 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 6 @0.003s 4%: 0.010+0.22+0.002 ms clock, 0.063+0.044/0.021/0.015+0.017 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 7 @0.004s 5%: 0.050+0.089+0.002 ms clock, 0.30+0.040/0.028/0.002+0.013 ms cpu, 4->4->0 MB, 5 MB goal, 6 P
gc 8 @0.005s 5%: 0.009+0.34+0.003 ms clock, 0.055+0.042/0.067/0.016+0.019 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 9 @0.005s 6%: 0.008+0.21+0.095 ms clock, 0.053+0.047/0.020/0.001+0.57 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 10 @0.006s 5%: 0.007+0.27+0.002 ms clock, 0.047+0.039/0.073/0.014+0.015 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 11 @0.006s 6%: 0.081+0.33+0.003 ms clock, 0.48+0.040/0.093/0.013+0.018 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 12 @0.007s 6%: 0.008+0.20+0.002 ms clock, 0.052+0.045/0.035/0+0.015 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 13 @0.007s 6%: 0.008+0.27+0.003 ms clock, 0.049+0.041/0.080/0.011+0.018 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 14 @0.008s 6%: 0.007+0.25+0.002 ms clock, 0.047+0.040/0.020/0+0.015 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 15 @0.009s 6%: 0.080+0.24+0.003 ms clock, 0.48+0.042/0.067/0.012+0.019 ms cpu, 4->5->1 MB, 5 MB goal, 6 P
gc 16 @0.009s 7%: 0.066+0.11+0.001 ms clock, 0.40+0.040/0.018/0+0.011 ms cpu, 4->4->0 MB, 5 MB goal, 6 P

gc 2 @0.001s 3%: 0.023+0.29+0.10 ms clock, 0.13+0.043/0.021/0+0.61 ms cpu, 5->6->1 MB, 6 MB goal, 6 P

以此条结果讲解字段意思

字段含义
gc 2第二个 GC 周期
0.001程序开始后的 0.001 秒
3%该 GC 周期中 CPU 的使用率
0.023标记开始时， STW 所花费的时间（wall clock）
0.029标记过程中，并发标记所花费的时间（wall clock）
0.10标记终止时， STW 所花费的时间（wall clock）
0.13标记开始时， STW 所花费的时间（cpu time）
0.043标记过程中，标记辅助所花费的时间（cpu time）
0.021标记过程中，并发标记所花费的时间（cpu time）
0.0标记过程中，GC 空闲的时间（cpu time）
0.61标记终止时， STW 所花费的时间（cpu time）
5标记开始时，堆的大小的实际值
6标记结束时，堆的大小的实际值
1标记结束时，标记为存活的对象大小
6标记结束时，堆的大小的预测值
6P 的数量

可以这么理解，本次GC为第二次GC周期，占用了3%的CPU来执行这次GC。本次GC所花的STW扫描时间，STW并发标记时间，即STW清扫的总时间为0.10ms wall clock。然后，本次GC占用的CPU时间为0.61ms。标记钱实际堆大小为5MB，结束时为6MB，清扫存活下来的为1MB。此GC基于6核CPU(约等于)。

wall clock 是指开始执行到完成所经历的实际时间，包括其他程序和本程序所消耗的时间；cpu time 是指特定程序使用 CPU 的时间；他们存在以下关系：

  • wall clock < cpu time: 充分利用多核
  • wall clock ≈ cpu time: 未并行执行
  • wall clock > cpu time: 多核优势不明显
go tool trace trace.out

将上述代码块改为如下代码

func main() {
	f, _ := os.Create("trace.out")
	defer f.Close()
	trace.Start(f)
	defer trace.Stop()

	for n := 1; n < 1000; n++ {
		allocate()
	}
}

func allocate() {
	_ = make([]byte, 1<<20)
}

通过go tool分析trace.out，执行完代码后可以得到一个trace.out，然后再执行go tool trace trace.out，会启动一个web server

在这里插入图片描述

网址输入后得到

在这里插入图片描述

点击第一个链接view trace

在这里插入图片描述

蓝色区域就是背景GC在执行的时间

堆就是我们通过allocate分配的内存

绿色为用户代码运行在系统线程上

debug.ReadGCStats
func main() {
	go printGCStats()
	for n := 1; n < 1000; n++ {
		allocate()
	}
	select {

	}
}

func printGCStats() {
	t := time.NewTicker(time.Second)
	s := debug.GCStats{}
	for {
		select {
		case <-t.C:
			debug.ReadGCStats(&s)
			fmt.Printf("gc %d last@%v, PauseTotal %v\n", s.NumGC, s.LastGC, s.PauseTotal)
		}
	}
}

func allocate() {
	_ = make([]byte, 1<<20)
}

type GCStats struct {
	LastGC         time.Time       // 上次一次收集时间
	NumGC          int64           // gc总次数
	PauseTotal     time.Duration   // 总共gc暂停的时间
	Pause          []time.Duration // 暂停的时间切片，每次暂停的花费时间，倒叙
	PauseEnd       []time.Time     // 暂停结束的时间点，倒叙
	PauseQuantiles []time.Duration
}

在这里插入图片描述

GC 调优

只有多写，多靠生产积累经验

资料来源

若有出处未贴出，请私信，马上补上

  1. https://www.jianshu.com/p/4c5a303af470
  2. https://zhuanlan.zhihu.com/p/150642189
  3. https://www.jianshu.com/p/3fc4450e1bbd
  4. https://www.jianshu.com/p/4a972dc959ca
  5. https://www.jianshu.com/p/4a972dc959ca
  6. https://www.cnblogs.com/dongl961230/p/13280415.html
  7. https://mp.weixin.qq.com/s/o2oMMh0PF5ZSoYD0XOBY2Q
非晓为骁
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GC 中的根结点
魏小言的博客
01-05 865
# GC 中的根结点 在 GC 策略中，根结点扮演着及为重要的角色。 以 Goland 为例，聊一下，根结点具体指的是什么？ ## 根结点 包括三部分内容： 1、全局变量，生命周期贯穿程序的变量； 2、执行栈，groutine 执行栈的变量及指向堆内存的指针； 3、寄存器，参与计算的指针或变量； ## Q&A 1、哪些 GC 策略需要从根结点出发做链路分析？ >请关注后续博文 ## 附录 程序错误中，80% 是语法错误，16% 是简单的逻辑错误，4% 才是困难的问题。
mysqldriver-go：GC优化MySQL驱动程序
02-20
mysqldriver-go 目录 动机 有许多实现接口MySQL驱动程序。 但是，使用此通用接口，尤其是在方法中，需要在堆中存储许多对象。 从数据库中读取大量记录会大大增加垃圾回收（GC）的暂停时间，这对于高吞吐量，低延迟...
GO GC 垃圾回收机制
weixin_33709590的博客
02-15 403
垃圾回收(Garbage Collection，简称GC)是编程语言中提供的内存管理功能。 在传统的系统级编程语言（主要指C/C++）中，程序员定义了一个变量，就是在内存中开辟了一段相应的空间来存值。由于内存是有限的，所以当程序不再需要使用某个变量的时候，就需要销毁该对象并释放其所占用的内存资源，好重新利用这段空间。在C/C++中，释放无...
go GC 垃圾回收机制
最新发布
daemon365的博客
05-28 1036
​ 以上便是Golang的GC全部的标记-清除逻辑及场景演示全过程。GoV1.3- 普通标记清除法，整体过程需要启动STW，效率极低。GoV1.5- 三色标记法， 堆空间启动写屏障，栈空间不启动，全部扫描之后，需要重新扫描一次栈(需要STW)，效率普通GoV1.8-三色标记法，混合写屏障机制， 栈空间不启动，堆空间启动。整个过程几乎不需要STW，效率较高。
go GC（垃圾回收）
weixin_45919793的博客
03-04 5284
目录什么是GCgo语言中的GC标记清除法三色标记法两种不变式go对上述规则的两种实现机制：插入写屏障删除写屏障混合写屏障法总结 什么是GC GC 堆内存上分配的数据对象，不会再使用时，不会自动释放内存，就变成垃圾，在程序的运行过程中，如果不能及时清理，会导致越来越多的内存空间被浪费，导致系统性能下降。 因此需要内存回收，内存回收分为两种方式 1.手动释放占用的内存空间 可能会出现的问题： 悬挂指针： 释放的早了，后续对数据的访问就会出错，因为对应的内存空间可能已经清空，重新分配，甚至是归还给操作系统了。 内
图解 Go GC
梦醒人间
04-12 357
转载自曹大公众号，不光是图，还有动画，读完对 Go GC 会有一个高层次的理解。这一篇是之前给极客时间 tony bai 老师专栏的供稿，经过编辑的同意，延迟几个月后可以在我的个人号上发出~本文内容只作了解，不建议作为面试题考察。武林秘籍救不了段错误包教包会包分配在各种流传甚广的 C 语言葵花宝典里，一般都有这么一条神秘的规则，不能返回局部变量：int*func(vo...
GO GC
shay的博客
04-23 393
从内存说起 我们知道程序运行时使用的常量变量其实都是存储在内存中的，所谓垃圾回收也就是将程序占用了，但现在已经不再使用的内存空间进行回收。那内存中都存储了些什么东西呢 代码区：存储给cpu运行时读取用的我们编译好的代码 数据区：存储全局变量 我们的程序在运行的时候，与我们接触更多的是堆区和栈区，大家都知道我们在程序中声明的变量会分配到这两个区域中 对于go程序来说，我们一般不需要关心一个变量到底被go分配到了堆区还是栈区，但这里姑且还是提一下go的分配原则 是否有在其他地方（非局部）被引用。只要有可能被
自动调整您的GOGC值___下载.zip
04-22
在Go编程语言中，GOGC是一个非常关键的环境变量，它直接影响到程序的内存管理和性能。这个压缩包“自动调整您的GOGC值___下载.zip”似乎包含了一个名为“gogctuner-master”的项目，这可能是一个工具，用于动态地、...
Go 1.6 GC improvements
08-04
Go 1.6 GC improvements.pdf
Go-gclog是一个go日志管理库
08-14
Go-gclog是一个专为Go语言开发者设计的日志管理库，它在go标准库的log基础上进行了扩展，提供了更高级别的功能，以满足复杂的应用场景下日志管理和维护的需求。这个库的核心特性包括动态日志级别变更、自动日志切分...
Go-P2P网络
08-14
Go-P2P网络是一种基于Go语言实现的对等网络架构，它充分利用了P2P（Peer-to-Peer）技术的特点，让网络中的每个节点都具备服务提供者和消费者的身份。在P2P网络中，没有中心化的服务器，所有的参与者都是平等的，这种...
用于Go的缓存库，GC开销为零。-Golang开发
05-26
FreeCache-用于Go的缓存库，具有零GC开销和高并发性能。 内存中的对象长期存在会带来昂贵的GC开销，有了FreeCache，您就可以在内存中缓存无限数量的对象，而无需i FreeCache-Go的缓存库，GC开销为零，并发性能很高。 内存中的对象长期存在会带来昂贵的GC开销，使用FreeCache，您可以在内存中缓存无限数量的对象，而不会增加延迟和吞吐量。 功能存储数亿个条目零GC开销大量并发线程安全访问Pure Go实现过期支持几乎LRU算法严格限制的内存使用附带一个支持以下任务的玩具服务器
Go GC
mojolang
05-09 251
Go GC 用Go，你可以很容易地创建出低延时的应用。Go GC似乎比其他语言的运行时要简单得多。对于Go 1.10版本，它的垃圾收集器是Concurrent Mask & Sweep (CMS)，它不是压缩的，也不是分代的。这一点跟JVM不同。 它是一个，并行标记，用一个写屏障（写的时候阻塞）的清理（程序）。它是非分代，非压缩的。-- mgc.go 下面是Java G...
Go语言的GC详解
weixin_44879611的博客
04-07 3471
前言 Garbage Collection (GC)是⼀种⾃动管理内存的⽅式。⽀持GC的语⾔⽆需⼿动管理内存，程序后 台⾃动判断对象。是否存活并回收其内存空间，使开发⼈员从内存管理上解脱出来。 垃圾回收机制 引⽤计数 标记清除 三⾊标记 分代收集 发展 版本 ——发布时间——GC ——————————STW时间 v 1.1 ——2013/5 ——STW ——————————百ms-⼏百ms级别...
[转]Go程序GC优化经验分享
热门推荐
heiyeluren的blog（黑夜路人的开源世界）
12-25 1万+
作者：达达来源：http://1234n.com/?post/yzsrwa最近一段时间对《仙侠道》的服务端进行了一系列针对GC的调优，这里跟各位分享一下调优的经验。游戏第一次上线的时候，大部分精力都投入在做cpuprof和memprof找性能瓶颈和内存泄漏上，没有关注过Go的GC运行情况。有一次cpuprof里的scanblock调用所占的比例让我注意到Go的GC所带来的性能消耗，记得那份cpup
GoGC整理
柠檬柠檬C的博客
02-24 955
引用自《Go GC 20 问》https://mp.weixin.qq.com/s/o2oMMh0PF5ZSoYD0XOBY2Q 含义 GarbageCollection 垃圾回收，一种自动内存管理机制 根集合，在GC时最先检查，包括： 全局变量 执行栈 寄存器 常见的GC方式 追踪式 标记清理：从根对象触发，标记清扫可回收的对象 标记整理：为了解决内存碎片，将对象尽可能整理到一块连续内存 增...
java垃圾回收算法之-标记压缩
JJ_nan的博客
05-21 2409
转自:http://www.jianshu.com/p/698eb5e1ccb9 前言 内存碎片一直是非移动垃圾回收器(指在垃圾回收时不进行对象的移动)的一个问题，比如说在前面的标记-清除垃圾回收器就有这样的问题。而标记-压缩垃圾回收算法能够有效的缓解这一问题。 算法原理 既然叫标记-压缩算法，那么它也分为两个阶段，一个是标记(mark)，一个是压缩(compact). 其
go GC - 笔记
shunuanwei的博客
10-28 179
常见的垃圾回收机制 一 : 引用计数: 当引用该对象的对象被销毁或者更新时,被引用的对象的引用计数自动减一; 当被引用对象被创建或者被赋值给其他对象时引用计数自动加一; 当引用计数为0时,立即回收对象; 二 : 标记清除: 从根变量开始,遍历所有被引用的对象,对能够通过应用遍历的访问到的所有的对象进行标记为"被引用",标记完成之后,将没有遍历访问到的内存进行回收(有可能会伴随碎片整理); 一开始的标记清除,在垃圾回收时,都会暂停当前所有正常代码的运行,因此这种回收机制对系统的正常运行比较大,但后来出现的三
Go语言中的GC机制
爱拍凯特的专栏
01-23 3018
Go语言和C/C++语言的一个显著的特点是Go中对象内存空间的回收是通过GC机制来完成的，不需要像C++一样通过程序员的手动申请和释放，所以Go中相对不容易出现内存泄漏，不过也不是绝对的（后面会在写一篇文章来说明Go中的内存泄漏和Gorotinue泄漏，以及Go的内存逃逸），今天我们就来详细聊聊Go中的GC机制。首先要先说一下GC，GC机制是在Java语言被广泛使用之后所火起来的，像后来的脚本语言Python都支持GC，GO也支持GC。GC是对内存空间的自动释放，那我们首先说说如果对内存空间管理和分配。
go gc会stw吗
07-27
是的，Go语言的垃圾回收（GC）机制会导致“stop the world”（STW）的情况发生。当垃圾回收器运行时，它会暂停程序的执行，直到垃圾回收完成。这意味着在STW期间，所有的goroutines都会停止执行。GC的时间取决于堆的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值