关于内存管理:golang的内存管理

https://blog.waterflow.link/articles/1663406367769

内存治理是治理计算机内存的过程，在主存和磁盘之间挪动过程以进步零碎的整体性能。内存治理的根本要求是提供办法来依据程序的申请动静的将局部内存调配给程序，并在不须要时开释它以供重用。

程序通过将他们的内存划分为执行特定工作的不同局部来治理他们。栈和堆就是这部分中的俩个，他们管理程序的未应用的内存并将其调配给不同类型的数据。当程序不再须要这些内存的时候就会开释他们，供后续应用。

正在运行的程序将其数据保留在这些逻辑区域之中。操作系统在将逻辑加载到内存时为全局变量和动态变量分配内存，并且在程序完结之前不会开释它。这些值不会被批改。另外俩个区域，堆和栈，更多的是动态分配的变量。在这些区域中，程序依据须要去调配和开释内存。这两个区域之间的区别上面会说到。

文本段是指标文件或内存中程序的一部分，其中蕴含可执行指令。文本段个别放在堆或栈的下方，以避免堆栈溢出被笼罩。

数据段是程序虚拟地址空间的一部分，其中蕴含由程序员初始化的全局变量和动态变量。

栈用于动态内存调配，就像数据结构中的栈，遵循后进先出。通常函数和局部变量会在栈上调配，当数据被调配到栈上或是从栈上弹出时，实际上没有任何物理挪动，只有保留在栈中的值会被批改。这使得从栈中存储和查问数据的过程十分快，因为不须要查找。咱们能够从它最下面的块中存储和查问数据。存储在栈上的任何数据都必须是无限且动态的。这意味着数据的大小在编译时是已知的。堆的内存治理简单明了，由操作系统实现。因为栈的大小是无限的，咱们可能会在这里遇到堆栈溢出谬误。

这里的堆和数据结构中的堆是没有关系的。堆用于 动态内存调配。栈只容许在顶部进行调配和开释，而程序能够在堆中的任何地位调配或开释内存。程序必须以与其调配相同的程序将内存返回到栈。然而程序能够以任何程序将内存返回到堆中。这意味着堆比栈更灵便。指针、数组和大数据结构通常存储在堆中。

存储在堆上的数据必须造成一个足够大的间断块，以应用单个内存块满足申请。此属性减少了堆的复杂性。首先，执行调配操作的代码必须扫描堆，直到找到足够大的间断内存块来满足申请。其次，当内存返回堆时，必须合并相邻的已开释块，以更好地适应将来对大块内存的申请。这种减少的复杂性意味着应用堆治理内存比应用堆栈慢。

堆内存调配计划不提供主动解除调配。咱们须要应用 垃圾回收器 来删除未应用的对象，以便无效地应用内存。

与栈相比，堆更慢，因为查找数据的过程波及更多。
堆比栈能够存储更多的数据。
堆以动静大小 存储数据；栈以动态大小 存储数据。
堆在应用程序的线程之间 共享。
堆因为其动静个性而 更难治理。
当咱们议论内存治理时，咱们次要是在议论治理堆内存。
堆内存调配不是 线程平安的，因为存储在此空间中的数据对所有线程都是可拜访或可见的。

内存是无限的。如果一个程序持续耗费内存而不开释它，它将耗尽内存并自行解体。因而，软件程序不能得心应手地持续应用内存，它会导致其余程序和过程耗尽内存。因为这一点的重要性，大多数编程语言（包含 Go）都提供了主动内存治理的办法。

Go 反对主动内存治理，例如主动内存调配和主动垃圾回收，防止了很多暗藏的 bug。

在 Go 中，每个线程都有本人的堆栈。当咱们启动一个线程时，咱们调配一块内存用作该线程的堆栈。当这块内存不够用时，问题就来了。为了克服这个问题，咱们能够减少堆栈的默认大小，但减少堆栈的大小意味着每个线程的大小都会减少。如果咱们想应用大量线程，这将十分低效。

另一种抉择是独自决定每个线程的堆栈大小。同样，在咱们有很多线程的设置中，这将是低效的，因为咱们须要弄清楚咱们应该为每个堆栈调配多少内存。

Go 的创建者想出的不是给每个 goroutine 一个固定数量的堆栈内存，而是 Go 运行时尝试依据须要为 goroutine 提供所需的堆栈空间。这样咱们在创立线程时就不须要思考堆栈大小了。

goroutine 以 2 kb 的堆栈大小开始，能够依据须要增长和放大。Go 查看它行将执行的函数所需的堆栈数量是否可用，如果不够用，则调用 morestack 调配一个新帧，而后才执行该函数。当该函数退出时，它的返回参数被复制回原始堆栈帧，并且任何不须要的堆栈空间都被开释。

堆栈也有下限。如果达到此限度，咱们的应用程序将 panic 并停止。

Go 在两个中央分配内存：一个用于动态分配的全局堆和一个用于每个 goroutine 的本地堆栈。Go 与许多垃圾收集语言相比的一个次要区别是，许多对象间接调配在程序堆上。Go 更喜爱在栈上调配。栈调配代价更低，因为它只须要两条 CPU 指令：一条推入栈进行调配，另一条从栈中开释。

可怜的是，并非所有数据都能够应用栈上调配的内存。栈调配要求能够在编译时确定变量的生命周期和内存占用。如果无奈确定，则在运行时动态分配到堆上。

Go 编译器应用一个称为 逃逸剖析 的过程来查找其生命周期在编译时已知的对象，并将它们调配到栈上而不是在垃圾回收的堆内存中。根本思维是在编译时做垃圾回收的工作。编译器跨代码区域跟踪变量的范畴。它应用这些数据来确定哪些变量持有一组查看，以证实它们的生命周期在运行时是齐全可知的。如果变量通过了这些查看，则能够在栈上调配值。如果不是，就代表逃逸，并且必须进行堆调配。

内存是在栈上调配还是逃到堆上齐全取决于你如何应用内存，而不是你如何申明变量。

能够通过上面的命令查看是否有内存逃逸，go build -gcflags '-m'。

垃圾回收是主动内存治理的一种模式。垃圾回收器 尝试回收由程序调配但不再被援用的内存。

Go 的垃圾回收器是一个 非分代并发、三色标记和清理垃圾回收器。

分代垃圾回收器专一于最近调配的对象，因为它假如像长期变量这样的短期对象最常被回收。

Go 编译器更喜爱在栈上调配对象，短期对象通常调配在栈上而不是堆上；这意味着不须要分代 GC。

Go 的垃圾回收分为两个阶段，标记阶段 和革除阶段 。GC 应用三色算法来剖析内存块的应用状况。该算法首先将仍被援用的对象标记为“沉闷”，并在下一阶段（扫描）开释不沉闷对象的内存。

导致垃圾回收代价高次要因素之一是堆上的对象数量。通过优化咱们的代码以缩小堆上长寿命对象的数量，咱们能够最大限度地缩小破费在 GC 上的资源，并进步咱们的零碎性能。

重构构造

在读取数据时，古代计算机 CPU 的外部数据寄存器能够保留和解决 64 位。这称为字长。它通常是 32 位或 64 位的。

当咱们不对齐数据以适应字长时，会增加填充以正确对齐内存中的字段，以便下一个字段能够从一个字长倍数的偏移量开始。

当数据天然对齐时，古代 CPU 硬件最无效地执行对内存的读取和写入。Go 编译器应用所需的对齐来确保并排存储的内存能够应用公倍数拜访。它的值等于构造中最大字段所需的内存大小。

在 Go 中创立 struct 时，会为其调配一个 间断的内存块。Go 内存分配器不会针对数据结构对齐进行优化，因而通过重新排列构造的字段，您能够通过升高填充来升高内存使用量。

通常 go 中的类型对应的字节大小如下

/**
var a bool          // 1 字节
var b int16         // 2 字节
var c int32         // 4 字节
var d int64         // 8 字节
var e int32         // 4 字节
var f int64         // 8 字节
var g int           // 8 字节
var h string        // 16 字节
var i float32       // 4 字节
var j float64       // 8 字节
var k interface{}   // 16 字节
var l time.Time     // 24 字节，构造体字节数不稳固
var m time.Timer    // 80 字节，构造体字节不稳固
var n time.Duration // 8 字节
var o []byte        // 24 字节
**/

例如，上面 User

type User1 struct {
    Age    uint8 // 1 字节
    Hunger int64 // 8 字节
    Happy  bool  // 1 字节
}

能够看到 10 个字节就能保留这些属性，然而咱们能够看下理论占用了多少字节：

go run struct.go
Size of main.User1 struct: 24 bytes

咱们能够批改下 User 的构造

type User1 struct {
    Hunger int64 // 8 字节
    Age    uint8 // 1 字节
    Happy  bool  // 1 字节
}

看下后果，缩小了 8 个字节的长度

go run struct.go
Size of main.User1 struct: 16 bytes

窍门就是依据字段的大小降序排列这些字段，前面的 Age 和 Happy 因为没有超过一个机器字，非配了 8 个字节。所以总共调配了 16 字节。

残缺的代码如下：

package main

import (
    "fmt"
    "unsafe"
)

/**
var a bool          // 1 字节
var b int16         // 2 字节
var c int32         // 4 字节
var d int64         // 8 字节
var e int32         // 4 字节
var f int64         // 8 字节
var g int           // 8 字节
var h string        // 16 字节
var i float32       // 4 字节
var j float64       // 8 字节
var k interface{}   // 16 字节
var l time.Time     // 24 字节，构造体字节数不稳固
var m time.Timer    // 80 字节，构造体字节不稳固
var n time.Duration // 8 字节
var o []byte        // 24 字节
var p uint8         // 1 字节
**/

type User1 struct {
    Age    uint8 // 1 字节
    Hunger int64 // 8 字节
    Happy  bool  // 1 字节
}

type User2 struct {
    Hunger int64 // 8 字节
    Age    uint8 // 1 字节
    Happy  bool  // 1 字节
}

var user1 User1
var user2 User2

func main() {fmt.Printf("Size of %T struct: %d bytes\n", user1, unsafe.Sizeof(user1))

    fmt.Printf("Size of %T struct: %d bytes\n", user2, unsafe.Sizeof(user2))
}

与其让对象存在于堆上，不如将它们创立为值而不是按需援用。例如，如果咱们须要用户申请中每个我的项目的一些数据，而不是事后计算并将其存储在一个长期存在的映射中，咱们能够基于每个申请计算它以缩小堆上的对象数量。

如果咱们有一个对象的援用，并且对象自身蕴含更多的指针，那么这些都被认为是堆上的单个对象，即便它们可能是嵌套的。通过将这些嵌套值更改为非指针，咱们能够缩小要扫描的对象的数量。

因为字符串 / 字节数组在底层被视为指针，因而每个数组都是堆上的一个对象。如果可能，尝试将它们示意为其余非指针值，例如整数 / 浮点数、工夫。

原文：

https://medium.com/@ali.can/memory-optimization-in-go-23a56544ccc0

关于内存管理:golang的内存管理

0.1、索引

1、内存治理

2、经典的内存模型

文本段

初始化数据和未初始化数据段

栈

堆

栈和堆的区别

内存调配的重要性

3、go 的内存模型

4、垃圾回收

不必回收垃圾，然而能够缩小垃圾

缩小长生命周期对象的数量

删除指针内的指针

防止不必要的字符串 / 字节数组调配

Just My Socks（注册教程内含优惠码）

关于内存管理:golang的内存管理

0.1、索引

1、内存治理

2、经典的内存模型

文本段

初始化数据和未初始化数据段

栈

堆

栈和堆的区别

内存调配的重要性

3、go 的内存模型

4、垃圾回收

不必回收垃圾，然而能够缩小垃圾

缩小长生命周期对象的数量

删除指针内的指针

防止不必要的字符串 / 字节数组调配

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）