并发相关
1.怎么控制并发数？
2.多个goroutine对同一个map写会panic吗？
3.如何优雅的实现一个goroutine池？（手写代码）
4.select可以干什么？
5.主协程如何等其余协程完再操作？
内存相关
1.谈谈内存泄漏，什么情况下内存会泄露？怎么定位排查内存泄漏问题？
内存泄漏 是指程序在运行过程中，动态分配的内存无法被正确释放或回收，导致这些内存被占用但不再被使用，最终可能会导致程序的内存耗尽或崩溃。虽然 Go 语言有垃圾回收（GC）机制来管理堆内存的释放，但这并不意味着内存泄漏永远不会发生。如果程序保留了对不需要的对象的引用，GC 将无法释放这些对象的内存，造成内存泄漏。
内存泄漏的常见原因
内存泄漏通常发生在某些资源（例如内存、文件描述符、网络连接等）被分配后，没有被及时释放，或者对象被不必要的引用持有而无法被垃圾回收器回收。
以下是一些常见的内存泄漏原因：
- 全局变量或静态变量持有不必要的引用全局变量或静态变量如果持有对某个对象的引用，而该对象不再需要使用，那么这些对象的内存就无法被垃圾回收器释放。var cache = make(map[string]*LargeObject)
func StoreObject(key string, obj *LargeObject) {
cache[key] = obj // cache 持有对对象的引用，无法释放
} - 未关闭的 GoroutineGo 语言中的 Goroutine 是轻量级线程，但是如果 Goroutine 没有及时退出，它们仍然会占用系统资源（包括内存）。例如，Goroutine 中的死循环或者无限阻塞会导致 Goroutine 无法正常结束，从而导致内存泄漏。func leak() {
ch := make(chan int)
go func() {
for {
select {
case <-ch:
return
}
}
}()
} //Goroutine 中的 `select` 语句会一直阻塞，因为 `ch` 永远不会被关闭或者发送数据，导致这个 Goroutine 永远不会退出。 - 未关闭的文件、网络连接、数据库连接如果打开的文件、网络连接或者数据库连接没有及时关闭，会导致资源泄漏，进而引发内存泄漏问题。func readFile() {
f, _ := os.Open(“somefile.txt”)
defer f.Close() // 如果忘记关闭文件，会导致文件描述符泄漏
} - 循环引用当两个或多个对象相互引用，而它们都不再被外部使用时，GC 可能无法正确识别并回收它们。这种情况下，内存泄漏会发生，尽管在 Go 中循环引用问题通常通过垃圾回收机制解决，但某些情况下仍可能出现内存泄漏。
- 大量缓存未清理程序中的缓存机制如果没有合理的清理策略，也会导致内存泄漏。例如，当缓存没有定期清理过期数据时，系统的内存占用会逐渐增大。var cache = make(map[string]*LargeObject)
func StoreInCache(key string, obj *LargeObject) {
cache[key] = obj
// 如果没有过期机制，缓存会无限增长
} - 大型对象长期持有如果程序创建了非常大的数据结构（如大型数组、切片、映射等），但这些数据结构没有被及时释放，可能会导致内存泄漏。
如何定位和排查内存泄漏问题
1 使用 pprof 工具
Go 提供了 pprof 工具来分析内存使用情况和性能。你可以使用 pprof 来生成和分析内存剖析报告。
步骤：
- 在代码中添加
net/http/pprof：在你的程序中导入net/http/pprof，它会自动注册 pprof 的 HTTP 处理器。import _ “net/http/pprof” - 启动 HTTP 服务器：在程序中启动一个 HTTP 服务器来访问 pprof 的接口。go func() {
log.Println(http.ListenAndServe(“localhost:6060”, nil))
}() - 生成和查看内存剖析报告：运行你的程序，然后使用
go tool pprof来生成内存分析报告。go tool pprof http://localhost:6060/debug/pprof/heap这将启动pprof交互式命令行，你可以使用它来分析内存分配。 - 分析报告：在
pprof命令行中，可以使用top、list和web命令来查看内存分配情况。(pprof) top(pprof) webweb命令将生成一个图形化的报告，并在浏览器中打开。
2 使用 go test 和 testing 包
你可以在测试中使用 testing 包的 -memprofile 选项来捕获内存分配情况。
步骤：
- 运行测试并生成内存剖析文件：go test -memprofile mem.out
- 分析内存剖析文件：go tool pprof mem.out在
pprof命令行中，可以使用top和web等命令来分析内存使用情况。
观察内存逃逸的情况
go build -gcflags -m
2.什么是内存逃逸？什么情况下发生内存逃逸？
内存逃逸是指在程序执行过程中，原本应该分配在栈上的变量被编译器判定为需要分配在堆上。这种情况下，变量逃逸到堆内存中管理，而不是留在栈上。
内存逃逸的原因：内存逃逸的核心原因是变量的生命周期超出了函数的栈帧范围。Go 编译器在编译时会进行逃逸分析，决定变量应该分配在栈上还是堆上。
下面是一些常见的导致内存逃逸的情况：
- 变量地址被外部引用
当变量的地址被传递到其他函数，或者作为返回值返回时，编译器无法确定该地址是否会在函数返回后继续使用。因此，为了保证变量的生命周期超出当前函数栈帧，它们必须分配到堆上。
func foo() *int {
x := 10
return &x // x 的地址被返回，逃逸到堆上
}
- 闭包捕获外部变量
闭包（Closure）是指函数可以捕获其外部环境中的变量，并在之后的执行过程中使用它们。如果闭包捕获了栈上的变量，而闭包又在外部函数返回后仍然有效，变量就需要被分配到堆上。
func closure() func() {
s := "hello"
return func() { fmt.Println(s) } // s 被闭包捕获，可能逃逸到堆
}
- 动态类型和接口的使用
当变量被赋值给一个接口（interface{}）类型时，编译器通常无法在编译时确定具体的类型和大小，因此会选择将其分配到堆上。
func printAny(v interface{}) {
fmt.Println(v) // v 是接口类型，可能导致 v 逃逸到堆。由于 `v` 是一个接口类型，编译器需要将其动态分配到堆上。
}
- 变量生命周期超过函数的作用域
当一个变量的生命周期超过了函数的栈帧时，它将被分配到堆上。这种情况通常发生在变量被外部函数引用，或者作为返回值被返回时。
func example() {
s := "Go" // 分配在栈上
global = &s // s 逃逸到堆，因为它的地址被保存到了全局变量
}
- 变量大小较大
虽然 Go 的编译器不会总是基于大小来决定逃逸，但如果变量非常大，编译器可能会将其分配到堆上以节省栈空间。栈的大小是有限的，因此较大的数据结构，如大型数组或结构体，可能会逃逸。
func largeAllocation() {
var largeArray [1000]int // 如果数组过大，编译器可能将其分配到堆
}
3.Go如何分配内存的？
内存分配
Go 语言中的内存分配由以下几个部分组成：
1.1. 栈内存分配
- 栈帧：函数调用时，Go 运行时在栈上分配栈帧。栈帧用于存储函数的局部变量和返回地址。栈内存分配速度非常快，因为只涉及指针操作。
- 栈扩展：Go 的栈大小是动态的。栈会自动扩展或收缩以适应函数调用。每当栈空间不足时，Go 运行时会自动将栈扩展到新的内存区域，并将现有的栈帧复制到新栈上。
1.2. 堆内存分配
- 堆分配：用于分配生命周期超出当前函数调用的对象。堆内存分配比栈内存分配要慢一些，但可以存储更长生命周期的对象。
- 内存池：Go 使用内存池来管理堆上的内存分配。内存池包含多个大小固定的块，用于减少频繁的内存分配和释放带来的开销。
垃圾回收
Go 使用垃圾回收（GC）来管理堆上的内存，主要通过以下机制实现：
- 标记-清除算法：Go 的垃圾回收器使用标记-清除算法来回收不再使用的内存。GC 分为两个阶段：标记阶段和清除阶段。在标记阶段，GC 遍历所有活动的对象并标记它们。在清除阶段，GC 清理未被标记的对象，从而释放内存。
- 三色标记：Go 的 GC 使用三色标记算法来区分对象的状态（白色、灰色、黑色），以便在回收过程中处理不同类型的对象。
- 增量式 GC：Go 的垃圾回收器采用增量式策略，分为多个小阶段进行，从而减少对程序的暂停时间。这样可以在尽可能短的时间内完成垃圾回收操作。
内存分配优化
- 逃逸分析：Go 编译器使用逃逸分析来确定变量是否可以在栈上分配，或者是否需要在堆上分配。如果一个变量的生命周期超出了函数调用，它会被分配到堆上。如果变量只在函数调用内有效，它会被分配到栈上。
- 内存池：Go 的标准库提供了内存池（如
sync.Pool）来缓存和复用对象，从而减少频繁的内存分配和回收。 - 对象分配优化：Go 的运行时系统会优化内存分配，通过合并小块内存和减少内存碎片来提高效率。
4.channel分配在栈上还是堆上？那些对象分配在堆上？，那些对象分配在栈上？
- Channel 的内存分配
- Channel 的内存分配：在 Go 中，channel 是一个引用类型，其内存通常分配在堆上。即使在栈上创建了一个 channel 变量，这个 channel 变量只是一个指向堆上实际 channel 数据结构的指针。由于 channel 的生命周期可能超出创建它的函数调用，因此 channel 的实际数据结构通常分配在堆上。
- 栈内存分配
栈内存用于存储短生命周期的局部变量。具体来说：
- 局部变量：在函数内声明的局部变量，通常会在栈上分配。例如，在函数中声明的基本数据类型（如
int、float）和小型结构体。 - 函数参数：函数的参数在栈上分配。当参数被传递到函数中时，参数的拷贝会存储在栈帧中。
- 内联变量：当 Go 编译器通过逃逸分析确定变量可以在栈上分配时，这些变量会被分配在栈上。
- 堆内存分配
堆内存用于存储生命周期较长的对象或需要在多个函数之间共享的对象。具体来说：
- 长生命周期的对象：如果一个对象的生命周期超出了其创建函数的范围（例如，通过闭包或返回值传递），该对象通常会被分配在堆上。
- 逃逸的变量：通过逃逸分析确定需要在堆上分配的变量。这通常是因为变量在函数调用后仍然需要被访问。
- 复杂数据结构：例如，切片（slice）、映射（map）、channel、接口（interface）等，它们的底层实现通常会在堆上分配。
- 逃逸分析
Go 编译器使用逃逸分析来决定变量的内存分配：
- 栈分配：如果编译器确定变量的生命周期在函数调用内，且没有逃逸到函数外部，则会将变量分配在栈上。
- 堆分配：如果变量的生命周期超出了函数调用的范围（例如，通过返回值或闭包），则会将变量分配在堆上。
示例代码
下面的代码展示了不同类型的内存分配：
package main
import (
"fmt"
"runtime"
)
func main() {
// 声明一个局部变量
x := 10
// 声明一个 channel
ch := make(chan int)
// 声明一个局部函数
func() {
// 局部函数中的局部变量
y := 20
fmt.Println(y)
}()
// 输出 Go 运行时的内存统计信息
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Alloc = %v MiB\n", bToMb(m.Alloc))
fmt.Printf("TotalAlloc = %v MiB\n", bToMb(m.TotalAlloc))
fmt.Printf("Sys = %v MiB\n", bToMb(m.Sys))
fmt.Printf("NumGC = %v\n", m.NumGC)
}
func bToMb(b uint64) float64 {
return float64(b) / (1024 * 1024)
}
在这个示例中：
x和y是局部变量，会被分配在栈上（如果它们没有逃逸）。ch是一个 channel，会在堆上分配。- 匿名函数中的局部变量
y会在栈上分配，但如果它被逃逸到堆上，则会在堆上分配。
通过了解这些内存分配策略，你可以更有效地优化 Go 程序，确保适当使用栈和堆内存，避免不必要的内存分配和回收。
5.介绍一下大对象小对象，什么情况下导致GC压力大？
在 Go 语言的内存管理中，大对象和小对象的概念对于理解垃圾回收（GC）的压力和性能非常重要。以下是大对象和小对象的定义、它们对 GC 的影响，以及导致 GC 压力大的情况。
- 大对象与小对象
小对象：
- 定义：小对象通常指的是内存占用较小的对象，这些对象的大小通常在几 KB 或更小的范围内。典型的小对象包括简单的结构体、基本数据类型（如
int、float）、短生命周期的局部变量等。 - 特性：小对象在内存中占用空间较少，GC 处理这些对象时的开销相对较小。由于它们的数量可能非常庞大，GC 需要有效地管理和回收这些对象。
大对象：
- 定义：大对象是指占用大量内存的对象，通常是几 MB 或更大的数据结构。典型的大对象包括大型切片、映射、字符串、或大型自定义结构体。
- 特性：大对象的内存占用较高，在 GC 执行时需要更多的内存和时间来处理。大对象的分配和回收对 GC 的性能影响较大，尤其是在大对象频繁分配和释放的场景中。
- GC 压力大的情况
以下情况会导致 GC 压力增大，从而影响程序的性能：
2.1. 频繁的内存分配和回收：
- 如果程序频繁分配和回收大量的对象，GC 需要不断地跟踪和回收这些对象。这会增加 GC 的开销，导致 GC 压力增大。
2.2. 大量小对象：
- 即使单个小对象的内存占用很小，但大量的小对象会导致大量的 GC 活动。每次 GC 都需要检查这些对象的可达性，并处理大量的对象，这会导致 GC 的开销增大。
2.3. 大对象的分配和回收：
- 大对象的分配和回收需要更多的内存和时间。特别是当大对象频繁分配和释放时，GC 需要更多的资源来处理这些大对象的内存分配和回收。
2.4. 对象逃逸：
- 当变量的生命周期超出其创建函数的范围时，它们会被分配在堆上。大量的堆内存分配会增加 GC 的压力，因为 GC 需要管理和回收这些堆上的对象。
2.5. 内存碎片：
- 当程序中存在大量的对象分配和释放时，可能会导致内存碎片。内存碎片会影响 GC 的效率，因为 GC 需要处理内存碎片，可能会导致额外的开销。
2.6. 长时间的 GC 停顿：
- GC 停顿时间越长，程序的响应时间就越慢。长时间的 GC 停顿通常发生在 GC 需要处理大量的对象或大对象时。
- 减少 GC 压力的方法
3.1. 减少对象分配：
- 尽量复用对象，减少不必要的内存分配。使用内存池（如
sync.Pool）来缓存和复用对象，减少频繁的分配和回收。
3.2. 优化大对象使用：
- 尽量避免频繁分配和释放大对象。考虑使用内存映射文件或其他高效的数据存储方式来处理大数据量。
3.3. 减少对象逃逸：
- 通过逃逸分析，尽量将对象分配在栈上，而不是堆上。优化函数参数和返回值，减少不必要的堆分配。
3.4. 监控和调优 GC：
- 使用
pprof等工具监控 GC 的表现，了解 GC 的开销，并根据分析结果进行优化。
通过理解大对象和小对象的特性，以及导致 GC 压力增大的情况，你可以更有效地优化 Go 程序的内存管理和性能。
