当前位置： 首页 > article >正文

golang Pool实战与底层实现

article 2024/11/19 5:31:14

使用的go版本为 go1.21.2

首先我们写一个简单的Pool的使用代码

package main

import "sync"

var bytePool = sync.Pool{
	New: func() interface{} {
		b := make([]byte, 1024)
		return &b
	},
}

func main() {
	for j := 0; j < 10; j++ {
		obj := bytePool.Get().(*[]byte) // 获取一个[]byte
		_ = obj
		bytePool.Put(obj) // 用完再给放回去
	}
}

pool对象池的作用

  1. 减少内存分配： 通过池，可以减少对内存的频繁分配和释放，提高程序的内存利用率。
  2. 避免垃圾回收压力： 对象池中的对象在被使用后不会立即被释放，而是放回到池中等待复用。这有助于减轻垃圾回收的压力，因为对象可以在多次使用后才被真正释放。
  3. 提高性能： 复用对象可以避免不必要的对象创建和销毁开销，从而提高程序的性能。
    从demo上看好像没啥卵用，我们来进行一些压力测试
package main

import (
	"sync"
	"testing"
)

var bytePool = sync.Pool{
	New: func() interface{} {
		b := make([]byte, 1024)
		return &b
	},
}

func BenchmarkByteMake(b *testing.B) {
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < 10000; j++ {
			obj := make([]byte, 1024)
			_ = obj
		}
	}
}

func BenchmarkBytePool(b *testing.B) {
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < 10000; j++ {
			obj := bytePool.Get().(*[]byte) // 获取一个1024长度的[]byte
			_ = obj
			bytePool.Put(obj) // 用完再给放回去
		}
	}
}

看一下压测效果

可以看到执行效率高了好多倍

项目中没实际用到过，不过我们可以翻一下开源项目中是怎么用的

redis-v9 

 

Pool结构体

比较复杂有点套娃的意思

//代码位于 GOROOT/src/sync/pool.go L:49
type Pool struct {
  //防止Pool被复制, 君子协议，编译可以通过，某些编辑器会报waring
  //静态检测 go vet会出错
  //有兴趣可以看一下这里 https://github.com/golang/go/issues/8005#issuecomment-190753527
	noCopy noCopy

	local     unsafe.Pointer // 本地池，对应类型[P]poolLocal P指的是 GMP中的P.ID字段
	localSize uintptr        // 本地池大小

	victim     unsafe.Pointer // 上一个周期的本地池
	victimSize uintptr        // 上一个周期的本地池大小


	New func() any // 创建对象的方法，这个需要我们自己实现
}

type poolLocal struct { //本地池
	poolLocalInternal

	// 用128取模，确保结构体占据整数个缓存行，从而防止伪共享.
	pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
}

type poolLocalInternal struct {
	private interface{} // 本地P的私有字段
	shared  poolChain   // 双端链表, 任何P都可以进行popTail
}


//代码位于 GOROOT/src/sync/poolqueue.go L:194
type poolChain struct { // 双向队列
	//头部
	head *poolChainElt

	//尾部
	tail *poolChainElt
}


type poolChainElt struct { //环状队列
	poolDequeue 

	// next 由生产者原子性地写入，并由消费者原子性地读取, 从非nil转换为nil
	// prev 由消费者原子性地写入，并由生产者原子性地读取, 从非nil转换为nil
	next, prev *poolChainElt
}

//代码位于 GOROOT/src/sync/poolqueue.go L:19
type poolDequeue struct {
	//一个字段两个含义,高32位为头，低32位为尾部
	headTail uint64

	//环形缓存
	//vals[i].typ 为nil 说明该槽位为空
	vals []eface
}

type eface struct { //类型与值
	typ, val unsafe.Pointer
}

Get函数

//代码位于 GOROOT/src/sync/pool.go L:127
func (p *Pool) Get() any {
	if race.Enabled { // 使用竞态检查
		race.Disable() //竞态检查 禁用
	}
	l, pid := p.pin() //获取当前P的ID 与 poolLocal 详细见下方
	x := l.private //看看私有属性是否存在对象，如果存在就可以直接返回
	l.private = nil
	if x == nil { //
		//优先从链表的头部获取，
		x, _ = l.shared.popHead()
		if x == nil {// 慢读取路径
			x = p.getSlow(pid)
		}
	}
	runtime_procUnpin() //取消 P 的禁止抢占
	if race.Enabled { // 使用竞态检查
		race.Enable() //竞态检查 启用
		if x != nil {
			race.Acquire(poolRaceAddr(x))
		}
	}
	if x == nil && p.New != nil { //调度new方法重新生成一个对象
		x = p.New()
	}
	return x
}
pin函数
 

//代码位于 GOROOT/src/sync/pool.go L:127
func (p *Pool) pin() (*poolLocal, int) {
	//获取P的id
	pid := runtime_procPin()
	// 原子操作获取本地池大小
	// 本地池
	s := runtime_LoadAcquintptr(&p.localSize) // load-acquire
	l := p.local                              // load-consume
	if uintptr(pid) < s { //如果当前P.id 没有在local中越界，直接去获取值
		return indexLocal(l, pid), pid
	}
	return p.pinSlow() //慢获取
}

func (p *Pool) pinSlow() (*poolLocal, int) {
	//取消P的禁止抢占
	runtime_procUnpin()
	allPoolsMu.Lock() //加锁
	defer allPoolsMu.Unlock()
	pid := runtime_procPin() //获取P的id
	//获取本地池的大小与本地池
	s := p.localSize
	l := p.local
	if uintptr(pid) < s { //如果当前P.id 没有在local中越界，直接去获取值
		return indexLocal(l, pid), pid
	}
	if p.local == nil { //如果local为空，将他加入到allPools中
		allPools = append(allPools, p)
	}
	// GOMAXPROCS在GC之间发送了变化，重新分配p.load与p.localSize
	size := runtime.GOMAXPROCS(0)
	local := make([]poolLocal, size)
	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
	runtime_StoreReluintptr(&p.localSize, uintptr(size))     // store-release
	return &local[pid], pid
}


 

getSlow函数
 

//代码位于 GOROOT/src/sync/pool.go L:156
func (p *Pool) getSlow(pid int) any {
	// 原子获取本地池大小
	// 本地池
	size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
	locals := p.local                            // load-consume
	// 尝试从别的P poolLocal尾部获取local
	// 这个循环的方式有点东西(pid+i+1)%int(size)，优先从非pid的下标获取，最后一次是pid
	for i := 0; i < int(size); i++ {
		l := indexLocal(locals, (pid+i+1)%int(size))
		if x, _ := l.shared.popTail(); x != nil {
			return x
		}
	}

	// 原子获取上一周期本地池大小
	size = atomic.LoadUintptr(&p.victimSize)
	if uintptr(pid) >= size { //如果pid大于size 说明让回收掉了
		return nil
	}
	locals = p.victim
	l := indexLocal(locals, pid)
	if x := l.private; x != nil {//看看私有属性是否存在对象，如果存在就可以直接返回
		l.private = nil
		return x
	}
	// 尝试从别的P poolLocal尾部获取local
	for i := 0; i < int(size); i++ {
		l := indexLocal(locals, (pid+i)%int(size))
		if x, _ := l.shared.popTail(); x != nil {
			return x
		}
	}

	//将victimSize设置为0
	atomic.StoreUintptr(&p.victimSize, 0)

	return nil
}

 

 
 

Put函数
 

//代码位于 GOROOT/src/sync/pool.go L:95
func (p *Pool) Put(x any) {
	if x == nil { //如果写入的x为nil之间返回
		return
	}
	if race.Enabled { //使用竞态检查
		if fastrandn(4) == 0 {
			// Randomly drop x on floor.
			return
		}
		race.ReleaseMerge(poolRaceAddr(x))
		race.Disable() // 竞态检查 禁用
	}
	l, _ := p.pin() // 获取PoolLocal
	if l.private == nil { // 如果私有属性没有赋值
		l.private = x
	} else { //将x写入头
		l.shared.pushHead(x)
	}
	runtime_procUnpin()
	if race.Enabled { //使用竞态检查
		race.Enable() //竞态检查 启用
	}
}

 

 

pushHead函数解读
 

//代码位于 GOROOT/src/sync/poolqueue.go L:228
func (c *poolChain) pushHead(val any) {
	d := c.head
	if d == nil { //如果head为空，将head初始化为8长度的eface数组
		const initSize = 8 // Must be a power of 2
		d = new(poolChainElt)
		d.vals = make([]eface, initSize)
		c.head = d
		storePoolChainElt(&c.tail, d) //将新创建的节点，当做尾节点
	}

	if d.pushHead(val) { //对象入队
		return
	}

	// 走到这里说明满了。可扩容为2倍
	newSize := len(d.vals) * 2
	// 扩容大小 (1 << 32) / 4 超出将这个设置为(1 << 32) / 4
	if newSize >= dequeueLimit { 
		newSize = dequeueLimit
	}
	//新建poolChainElt将prev指向d
	d2 := &poolChainElt{prev: d}
	d2.vals = make([]eface, newSize)
	c.head = d2 //将新创建的节点，当做头节点
	storePoolChainElt(&d.next, d2) // 将老的节点指向，新节点
	d2.pushHead(val) //对象入队
}

 

 

 
 

延迟处理下标小技巧
 

package main

import (
	"fmt"
)

func main() {
	pid := 1
	size := 20

	for i := 0; i < int(size); i++ {
		if i == pid {
			continue
		}
		fmt.Println(i)
	}

	// 优化版本 pid会在最后一个打印处理
	for i := 0; i < size; i++ {
		index := (pid + i + 1) % size
          // 前面处理完以后直接return
		fmt.Println(index)
	}
}

 

总结
 

我们从上面的源码分析了解Pool的数据结构、Get、Put这些基本操作原理，在项目中我们可以使用比特位来减少内存的占用，从源码分析我们得知Go官方设计不允许进行Pool复制(君子协议), 还学到了一个延迟处理下标的小技巧。

                

        

        

				
				

					

					http://www.kler.cn/a/154252.html
					
				

                

                  
相关文章：

				  
                        

  • C/C++中使用MYSQL 
    • 


  • Py之pymupdf：基于langchain框架结合pymupdf库实现输出每个PDF页面的文本内容、元数据等 
    • 


  • 文心一言编写小球反弹程序并优化 
    • 


  • Ubuntu22.04LTS 部署前后端分离项目 
    • 


  • IDEA leetcode插件代码模板配置,登录闪退解决 
    • 


  • 若点集A=B则A必能恒等变换地变为B=A这一几何常识推翻直线（平面）公理 
    • 

                      
  • 
                        k8s(三): 基本概念-ReplicaSet与Deployment
                      
    • 
                    
                      
  • 
                        TA-Lib学习研究笔记——Price Transform （五）
                      
    • 
                    
                      
  • 
                        阿里千问Qwen-72 b在中文测试中击败了GPT-3.5
                      
    • 
                    
                      
  • 
                        【Matlab】如何快速入门一项新技能-以Matlab/Simulink入门为例
                      
    • 
                    
                      
  • 
                        C语言中的格式化输出符号：%d %c %p %x等
                      
    • 
                    
                      
  • 
                        750mA Linear Charger with Power Path Management
                      
    • 
                    
                      
  • 
                        Windows安装Mysql Workbench及常用操作
                      
    • 
                    
                      
  • 
                        vscode一直不能跳转函数定义或者别的定义c_cpp_properties.json、settings.json
                      
    • 
                    
                      
  • 
                        七、ZooKeeper选举机制
                      
    • 
                    
                      
  • 
                        深入浅出 Golang 中的直接依赖和间接依赖管理
                      
    • 
                    
                      
  • 
                        Fiddler抓包工具之fiddler设置抓HTTPS的请求证书安装
                      
    • 
                    
                      
  • 
                        (C++)盛水最多的容器--双指针法
                      
    • 
                    
                      
  • 
                        Jmeter组件执行顺序与作用域
                      
    • 
                    
                      
  • 
                        cuda 在 torch神经网络中哪些地方可以用？
                      
    • 
                    
                      
  • 
                        使用JSP+Servlet+MySQL实现登录注册功能
                      
    • 
                    
                      
  • 
                        Linux基础项目开发1:量产工具——UI系统(五)
                      
    • 
                    
                      
  • 
                        计算机网络408
                      
    • 
                    
                      
  • 
                        zabbix 监控
                      
    • 
                    
                      
  • 
                        【蓝桥杯选拔赛真题72】Scratch找一找 少儿编程scratch图形化编程 蓝桥杯创意编程选拔赛真题解析
                      
    • 
                    
                      
  • 
                        关于qiankun沙箱sandbox（面试题）
                      
    •