针对高并发场景中 golang 程序对内存分配和回收的优化，以下是四个主要技术：1. 内存池：预分配内存块，减少分配开销，消除碎片化。2. mmap：直接映射文件或资源到内存，提高访问速度。3. 对象池：预实例化对象，减少重复分配和析构。4. gc 调优：调整 gc 参数，优化垃圾回收频度和对象大小分配策略。实践中，使用内存池提升了高吞吐 web 服务的性能，避免了频繁的内存分配和回收，显著提高了响应时间和吞吐量。
在 Golang 的高并发场景中优化内存分配和回收
在高并发场景中，Golang 程序对内存分配和回收的效率至关重要。频繁的内存分配和回收会导致性能下降、延迟增加和应用程序不稳定。可以通过以下技术优化内存分配和回收：
1. 内存池
内存池是一种将预分配的内存块存储在池中的技术。当需要分配内存时，程序可以从池中获取已分配的块，而不是从操作系统分配新内存。这减少了内存分配的开销，并消除了碎片化。
import (
"sync"
"runtime"
)
type MemoryPool struct {
sync.Mutex
blocks [][]byte
}
func (p *MemoryPool) Get() []byte {
p.Lock()
defer p.Unlock()
if len(p.blocks) > 0 {
b := p.blocks[0]
p.blocks = p.blocks[1:]
return b
}
return make([]byte, 1024)
}
func (p *MemoryPool) Put(b []byte) {
p.Lock()
defer p.Unlock()
p.blocks = append(p.blocks, b)
}2. mmap
mmap（内存映射）允许程序将文件或其他资源直接映射到内存中。这绕过了操作系统内存分配机制，并提高了内存访问速度。
立即学习“go语言免费学习笔记（深入）”；
import (
"os"
"io"
)
func ReadFileWithMmap(filename string) {
f, err := os.OpenFile(filename, os.O_RDONLY, 0)
if err != nil {
// ...
}
defer f.Close()
stat, err := f.Stat()
if err != nil {
// ...
}
data, err := mmap.Map(f, mmap.RDWR, 0, stat.Size(), mmap.PROT_READ)
if err != nil {
// ...
}
// ...操作映射文件
mmap.Unmap(data)
}3. 对象池
对象池是一种将预实例化的对象存储在池中的技术。当需要对象时，程序可以从池中获取对象，而不是创建新对象。这减少了对象创建的开销，并消除对象的重复分配和析构。
import (
"sync"
"time"
)
type ObjectPool struct {
sync.Mutex
objects []interface{}
}
func (p *ObjectPool) Get() interface{} {
p.Lock()
defer p.Unlock()
if len(p.objects) > 0 {
o := p.objects[0]
p.objects = p.objects[1:]
return o
}
// ...创建新对象
return newObject()
}
func (p *ObjectPool) Put(o interface{}) {
p.Lock()
defer p.Unlock()
p.objects = append(p.objects, o)
}4. GC 调优
Go 程序有内置的垃圾回收器 (GC)。可以通过调整 GC 参数来优化 GC 的性能。
// 减少垃圾回收的频度 runtime.GOMAXPROCS(runtime.NumCPU()) runtime.SetGOMAXPROCS(runtime.NumCPU()) // 分配较小的对象，减少 GC 的开销 small_object_size = 1KB
实战案例
在以下示例中，我们使用内存池来提高 high-throughput Web 服务的性能。该服务生成大量的小型响应，并且对性能要求很高。
import (
"net/http"
"runtime"
)
const (
// 预分配内存块的大小
blockSize = 1024 * 1024
// 内存池中最大块数
maxBlocks = 10
)
var memoryPool *MemoryPool
func init() {
memoryPool = &MemoryPool{blocks: make([][]byte, 0, maxBlocks)}
for i := 0; i < maxBlocks; i++ {
memoryPool.Put(make([]byte, blockSize))
}
}
func handler(w http.ResponseWriter, r *http.Request) {
buf := memoryPool.Get()
// ...业务逻辑
memoryPool.Put(buf)
}通过使用内存池，我们避免了频繁的内存分配和回收，显著提高了服务的响应时间和吞吐量。
