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

Go语言底层(三): sync 锁 与 对象池

news 2025/6/6 5:40:48

1. 背景

在并发编程中，正确地管理共享资源是构建高性能程序的关键。Go 语言标准库中的 sync 包提供了一组基础而强大的并发原语，用于实现安全的协程间同步与资源控制。本文将简要介绍 sync 包中常用的类型和方法: sync 锁 与 对象池，帮助开发者更高效地编写并发安全的 Go 程序。

2. 锁

go语言是出了名的高并发利器 , 但在高并发场景下 , 伴随而来的数据安全问题是需要解决的。 加锁就是其中的一个解决办法。
多个线程同时访问临界区，锁住一些共享资源， 以防止并发访问这些共享数据时可能导致的数据不一致问题。
获取锁的线程可以正常访问临界区，未获取到锁的线程等待锁释放后可以尝试获取锁。
在这里插入图片描述

sync.Locker 是 go 标准库 sync 下定义的锁接口：

// A Locker represents an object that can be locked and unlocked.
type Locker interface {Lock()Unlock()
}

任何实现了 Lock 和 Unlock 两个方法的类，都可以作为一种锁的实现。
Go 语言包中的 sync 包提供了两种锁类型：sync.Mutex 和 sync.RWMutex，前者是互斥锁，后者是读写锁。

2.1 互斥锁 (sync.Mutex)

互斥即不可同时运行。即使用了互斥锁的两个代码片段互相排斥，只有其中一个代码片段执行完成后，另一个才能执行。
Go 标准库中提供了 sync.Mutex 互斥锁类型及其两个方法：

  • Lock 加锁
    使用 Lock () 加锁后，该线程不能再继续对其加锁，否则会 panic。只有在 unlock () 之后才能再次 Lock ()。异步调用 Lock ()，是正当的锁竞争，当然不会有 panic 了。适用于读写不确定场景，即读写次数没有明显的区别，并且只允许只有一个读或者写的场景，所以该锁也叫做全局锁。

  • Unlock 释放锁
    Unlock () 用于解锁 m，如果在使用 Unlock () 前未加锁，就会引起一个运行错误。已经锁定的 Mutex 并不与特定的 goroutine 相关联，这样可以利用一个 goroutine 对其加锁，再利用其他 goroutine 对其解锁。

2.1.1 使用方法

var lck sync.Mutex
func foo() {lck.Lock() defer lck.Unlock()// ...
}

2.2 读写锁 (sync.RWMutex)

读写锁是分别针对读操作和写操作进行锁定和解锁操作的互斥锁。
RWMutex 提供四个方法：

func (*RWMutex) Lock // 写锁定
func (*RWMutex) Unlock // 写解锁
func (*RWMutex) RLock // 读锁定
func (*RWMutex) RUnlock // 读解锁

  • 写锁定情况下，对读写锁进行读锁定或者写锁定，都将阻塞；而且读锁与写锁之间是互斥的；

  • 读锁定情况下，对读写锁进行写锁定，将阻塞；加读锁时不会阻塞；

操作1 \ 操作2RLock()（读锁）Lock()（写锁）RUnlock()Unlock()
RLock()✅ 并发允许❌ 阻塞等待写锁释放✅ 无影响✅ 无影响
Lock()❌ 阻塞等待读锁释放❌ 阻塞等待写锁释放✅ 无影响✅ 无影响
RUnlock()✅ 无影响✅ 无影响✅ 无影响✅ 无影响
Unlock()✅ 无影响✅ 无影响✅ 无影响✅ 无影响

读写锁的存在是为了解决读多写少时的性能问题，读场景较多时，读写锁可有效地减少锁阻塞的时间。

3. 对象池 (sync.Pool)

sync.Pool 的使用场景 : 保存和复用临时对象，减少内存分配，降低 GC 压力。
举例 : Gin 框架中的 context 包每次面对接口调用时都需要创建 ,贯穿整个调用链路。底层就使用对象池进行优化。

sync.Pool 是可伸缩的，同时也是并发安全的，其大小仅受限于内存的大小。sync.Pool 用于存储那些被分配了但是没有被使用，而未来可能会使用的值。

3.1 使用方法

只需要实现 New 函数即可。对象池中没有对象时，将会调用 New 函数创建。

初始化 :

var studentPool = sync.Pool{New: func() interface{} { return new(Student) },
}

关键操作 :

// Put adds x to the pool.
func (p *Pool) Put(x any);// Get selects an arbitrary item from the [Pool], removes it from the
// Pool, and returns it to the caller.
// Get may choose to ignore the pool and treat it as empty.
// Callers should not assume any relation between values passed to [Pool.Put] and
// the values returned by Get.
//
// If Get would otherwise return nil and p.New is non-nil, Get returns
// the result of calling p.New.
func (p *Pool) Get() any;

举例 :

stu := studentPool.Get().(*Student)
json.Unmarshal(buf, stu)
studentPool.Put(stu)
  • Get() 用于从对象池中获取对象，因为返回值是 interface{}，因此需要类型转换。
  • Put() 则是在对象使用完毕后，返回对象池。

3.2 底层解析

3.2.1 sync.Pool 数据结构

type Pool struct {noCopy noCopylocal     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocallocalSize uintptr        // size of the local arrayvictim     unsafe.Pointer // local from previous cyclevictimSize uintptr        // size of victims array// New optionally specifies a function to generate// a value when Get would otherwise return nil.// It may not be changed concurrently with calls to Get.New func() }

• noCopy 防拷贝标志；

• local 类型为 [P]poolLocal 的数组，数组容量 P 为 goroutine 处理器 P 的个数；

• victim 为经过一轮 GC 回收，暂存的上一轮 local；类型于二级缓存 , 随时可能被GC 回收

• New 为用户指定的工厂函数，当 Pool 内存量元素不足时，会调用该函数构造新的元素.

[P]poolLocal 数组
暂时存储对象的对象池 , 每个 poolLocal 逻辑处理器分为 private 和 sharedList 两部分缓存数据

type poolLocal struct {poolLocalInternal
}// Local per-P Pool appendix.
type poolLocalInternal struct {private any       // Can be used only by the respective P.shared  poolChain // Local P can pushHead/popHead; any P can popTail.
}

• poolLocal 为 Pool 中对应于某个 P 的缓存数据；

• poolLocalInternal.private：对应于某个 P 的私有元素，操作时无需加锁；

• poolLocalInternal.shared: 某个 P 下的共享元素链表，由于各 P 都有可能访问，因此需要加锁.
请添加图片描述

3.2.2 sync.Pool 的核心方法

3.2.2.1 Pool.Get

Get流程
在这里插入图片描述

func (p *Pool) Get() any {l, pid := p.pin()x := l.privatel.private = nilif x == nil {x, _ = l.shared.popHead()if x == nil {x = p.getSlow(pid)}}runtime_procUnpin()if x == nil && p.New != nil {x = p.New()}return x
}

• 调用 Pool.pin 方法，绑定当前 goroutine 与 P，并且取得该 P 对应的缓存数据；

• 尝试获取 P 缓存数据的私有元素 private；

• 倘若前一步失败，则尝试取 P 缓存数据中共享元素链表的头元素；

• 倘若前一步失败，则走入 Pool.getSlow 方法，尝试取其他 P 缓存数据中共享元素链表的尾元素；

• 同样在 Pool.getSlow 方法中，倘若前一步失败，则尝试从上轮 gc 前缓存中取元素（victim）；

• 调用 native 方法解绑 当前 goroutine 与 P

• 倘若（2）-（5）步均取值失败，调用用户的工厂方法，进行元素构造并返回.

3.2.2.1 Pool.Put

Put流程
请添加图片描述

/ Put adds x to the pool.
func (p *Pool) Put(x any) {if x == nil {return}l, _ := p.pin()if l.private == nil {l.private = x} else {l.shared.pushHead(x)}runtime_procUnpin()
}

• 判断存入元素 x 非空；

• 调用 Pool.pin 绑定当前 goroutine 与 P，并获取 P 的缓存数据；

• 倘若 P 缓存数据中的私有元素为空，则将 x 置为其私有元素；

• 倘若未走入（3）分支，则将 x 添加到 P 缓存数据共享链表的末尾；

• 解绑当前 goroutine 与 P.

3.2.2 对象池的回收

存入 pool 的对象会不定期被 go 运行时回收，因此 pool 没有容量概念，即便大量存入元素，也不会发生内存泄露.

具体回收时机是在 gc 时执行的：请添加图片描述

• 每个 Pool 首次执行 Get 方法时，会在内部首次调用 pinSlow 方法内将该 pool 添加到迁居的 allPools 数组中；

• 每次 gc 时，会将上一轮的 oldPools 清空，并将本轮 allPools 的元素赋给 oldPools，allPools 置空；

• 新置入 oldPools 的元素统一将 local 转移到 victim，并且将 local 置为空.

综上可以得见，最多两轮 gc，pool 内的对象资源将会全被回收.

参考作者 : 小徐先生的编程世界

http://www.xdnf.cn/news/881119.html

相关文章：

  • 结合Jenkins、Docker和Kubernetes等主流工具，部署Spring Boot自动化实战指南
  • 如何通过外网访问内网?哪个方案比较好用?跨网远程连接网络知识早知道
  • 在Docker里面运行Docker
  • Windows11：解决近期更新后无法上网的问题
  • .net ORM框架dapper批量插入
  • 案例分享--汽车制动卡钳DIC测量
  • PDF 转 HTML5 —— HTML5 填充图形不支持 Even-Odd 奇偶规则？（第二部分）
  • 智慧赋能：新能源汽车充电桩应用现状与管理升级方案
  • 矩阵分解相关知识点总结（二）
  • Playwright 测试框架 - Java
  • 【缺陷】温度对半导体缺陷电荷态跃迁能级的影响
  • React 样式方案与状态方案初探
  • AiPy实战：10分钟用AI造了个音乐游戏！
  • c++ 通过XOR自己实现一个对称分组加密算法
  • 谷歌披露威胁组织攻击方式：伪造Salesforce数据加载器实施钓鱼攻击
  • 使用 uv 工具快速部署并管理 vLLM 推理环境
  • [10-1]I2C通信协议 江协科技学习笔记（17个知识点）
  • 网站首页菜单两种布局vue+elementui顶部和左侧栏导航
  • 为什么需要自动下载浏览器驱动？
  • Linux（13）——Ext系列⽂件系统
  • Amazing晶焱科技:电子系统产品在多次静电放电测试后的退化案例
  • RKNN3588上部署 RTDETRV2
  • Day45
  • [Git] 分布式版本控制 远程仓库协作
  • C语言输入函数
  • 1、Go语言基础中的基础
  • Django之表格上传
  • Linux服务器如何安装wps?
  • Java中List的forEach用法详解
  • ObjectMapper 在 Spring 统一响应处理中的作用详解