用golang实现内存池
用golang做一个预分配的内存池，代码可以很小量做到。 实现细节，主要是一个链表，用来保存内存块.
定义2个值:
num 每次需要增长内存池的时候，预分配的内存块数量
size 预分配时，单个内存块的大小
一共两个类型：
Pool 内存池对象，管理grow动作， Get， Put等动作
Buffer 一个链表
初始化时:
type Pool struct {
lock sync.Mutex
free *Buffer
max int
num int
size int
}
// 初始化内存池的时候，调用grow做一次内存预分配
func (p *Pool) init(num, size int) {
p.num = num
p.size = size
p.max = num * size
p.grow()
}
func (p *Pool) grow() {
var (
i int
b *Buffer
bs []Buffer
buf []byte
)
buf = make([]byte, p.max) // 创建一个num * size大小的连续内存
bs = make([]Buffer, p.num) // 创建链表节点
p.free = &bs[0]
b = p.free
for i = 1; i < p.num; i++ { // 完成链表节点的首尾相连，引用前面的大内存块中的逐个内存块
b.buf = buf[(i-1)*p.size : i*p.size]
b.next = &bs[i]
b = b.next
}
b.buf = buf[(i-1)*p.size : i*p.size]
b.next = nil // 这是一个单向链表
return
}
链表对象结构是:
type Buffer struct {
buf []byte
next *Buffer // to next node
}
然后就是两个对外的接口, Get 和 Put
// 获取一个内存块
func (p *Pool) Get() (b *Buffer) {
p.lock.Lock()
if b = p.free; b == nil {
p.grow()
b = p.free
}
p.free = b.next
p.lock.Unlock()
return
}
// 释放一个内存块
func (p *Pool) Put(b *Buffer) {
p.lock.Lock()
b.next = p.free
p.free = b
p.lock.Unlock()
return
}
size的大小就是内存块的大小， 因此应根据实际使用场景变化， 比如用在tcp socket 的write buffer上的时候， 那么size就是你希望能buff住的write buffer大小。