- sync包 秀才 2025年2月14日 大约 20 分钟 Go语言 Go语言 golang go进阶 sync 并发安全 此页内容 1. sync.WaitGroup 1.1 使用channel实现等待 1.2 使用WaitGroup实现等待 2. sync.Once 2.1 sync.Once与init()的区别 3. sync.Lock 3.1 锁 4. sync.Map 5. sync/Atomic 5.1 atomic和mutex的区别 5.2 atomic.value 6. sync.pool 6.1 sync.pool使用方法 6.2 sync.pool使用场景 在前面学习 channel 的时候，我们说到在Go语言并发编程中，倡导使用通信共享内存，不要使用共享内存通信， goroutine 之间尽量通过 channel 来协作。而在其他的传统语言中，都是通过共享内存加上锁机制来保证并发安全的，同样Go语言也提供了对共享内存并发安全机制的支持，这些功能都存在于 sync 包下。 1. sync.WaitGroup 在前面很多 goroutine 的示例中，我们都是通过 time.Sleep() 方法让主 goroutine 等待一段时间以便子 gortoutine 能够执行完打印结果，显然这不是一个很好的办法，因为我们不知道所有的子 gortoutine 要多久才能执行完，不能确切的知道需要等待多久。那要怎么处理呢？ 1.1 使用channel实现等待 看下面例子：
package main
import (
"fmt"
)
func main() {
ch := make(chan struct{}, 10)
for i := 0; i < 10; i++ {
go func(i int) {
fmt.Printf("num:%d\n",i)
ch <- struct{}{}
}(i)
}
for i := 0; i < 10; i++ {
<-ch
}
fmt.Println("end")
}
运行结果：
num:0
num:2
num:1
num:4
num:6
num:7
num:5
num:8
num:9
num:3
end
我们在每个 goroutine 中，向管道里发送一条数据，这样我们在程序最后，通过 for 循环将管道里的数据全部取出，直到数据全部取出完毕才能继续后面的逻辑，这样就可以实现等待各个 goroutine 执行完。 但是，这样使用 channel 显得并不优雅，其次，我们得知道具体循环的次数，来创建管道的大小，假设次数非常的多，则需要申请同样数量大小的管道出来，对内存也是不小的开销。 1.2 使用WaitGroup实现等待 这里我们可以用 sync 包下的 WaitGroup 来实现，Go语言中可以使用 sync.WaitGroup 来实现并发任务的同步以及协程任务等待。 sync.WaitGroup 是一个对象，里面维护者一个计数器，并且通过三个方法来配合使用： (wg * WaitGroup) Add(delta int) 计数器加delta (wg *WaitGroup) Done() 计数器减1 (wg *WaitGroup) Wait() 会阻塞代码的运行，直至计数器减为0 先看示例：
package main
import (
"fmt"
"sync"
)
var wg sync.WaitGroup
func myGoroutine() {
defer wg.Done()
fmt.Println("myGoroutine!")
}
func main() {
wg.Add(10)
for i := 0; i < 10; i++ {
go myGoroutine()
}
wg.Wait()
fmt.Println("end!!!")
}
运行结果：
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
myGoroutine!
end!!!
程序首先把 wg 的计数设置为10，每个 for 循环运行完毕都把计数器减1， main 函数中执行到 wg.Wait() 会一直阻塞，直到 wg 的计数器为零。最后打印了10个 myGoroutine! ，是所有子 goroutine 任务结束后主 goroutine 才退出。 注意： sync.WaitGroup 对象的计数器不能为负数，否则会panic，在使用的过程中，我们需要保证 add() 的参数值，以及执行完 Done() 之后计数器大于等于零 2. sync.Once 在我们写项目的时候，程序中有很多的逻辑只需要执行一次，最典型的就是项目工程里配置文件的加载，我们只需要加载一次即可，让配置保存在内存中，下次使用的时候直接使用内存中的配置数据即可。这里就要用到 sync.Once 。 sync.Once 可以在代码的任意位置初始化和调用，并且线程安全。 sync.Once 最大的作用就是延迟初始化，对于一个 sync.Once 变量我们并不会在程序启动的时候初始化，而是在第一次用的它的时候才会初始化，并且只初始化这一次，初始化之后驻留在内存里，这就非常适合我们之前提到的配置文件加载场景，设想一下，如果是在程序刚开始就加载配置，若迟迟未被使用，则既浪费了内存，又延长了程序加载时间，而 sync.Once 就刚好解决了这个问题。 使用示例：
// 声明配置结构体Config
type Config struct{}
var instance *Config
var once sync.Once // 声明一个sync.Once变量
// 获取配置结构体
func InitConfig() *Config {
once.Do(func(){
instance = &Config{}
})
return instance
}
只有在第一次调用InitConfig()获取Config 指针的时候才会执行once.Do (func(){instance = &Config{} })语句，执行完之后instance就驻留在内存中，后面再次执行InitConfig()的时候，就直接返回内存中的instance。 2.1 sync.Once与init()的区别 有时候我们使用init()方法进行初始化，init()方法是在其所在的package首次加载时执行的，而sync.Once可以在代码的任意位置初始化和调用，是在第一次用的它的时候才会初始化。 3. sync.Lock 说到并发编程，就不得不谈一个老生常谈的问题，那就是资源竞争，也就是我们这节要讲的并发安全。因为一旦开启了多个 goroutine 去处理问题，那么这些 goroutine 就有可能在同一时间操作同一个系统资源，比如同一个变量，同一份文件等等，这里我们如果不加控制的话，可能会出现并发安全问题，在Go语言中，有两种方式来控制并发安全，锁和原子操作 举个例子，看下面代码
package main
import (
"fmt"
"sync"
)
var (
num int
wg = sync.WaitGroup{}
)
func add() {
defer wg.Done()
num += 1
}
func main() {
var n = 10 * 10 * 10 * 10
wg.Add(n)
for i := 0; i < n; i++ {
// 启动n个goroutine去累加num
go add()
}
// 等待所有goroutine执行完毕
wg.Wait()
// 不出意外的话，num应该等于n，但是，但是，但是实际上不一致！
fmt.Println(num == n)
}
运行结果：
false
我们用 n （这里是10000，可以自行修改，尽量数字大一点）个 goroutine 去给 num 做累加，最后并 num 并不等于 n ，这就是并发问题，同一时间有多个 goroutine 都在对 num 做 +1 操作，但是后一个并不是在前一次执行完的基础之上运行的，可能两次运行 num 的初始相同，这样前一个 num+1 的结果就被后一个覆盖了，看起来好像只做了一个加法。为了避免类似的并发安全问题，我们一般会采用下面两种方式处理，在go语言中并发相关的都在 sync 包下面。 3.1 锁 3.1.1 互斥锁Mutex 互斥锁是一种最常用的控制并发安全的方式，它在同一时间只允许一个goroutine对共享资源进行访问。 互斥锁的声明方式如下：
var lock sync.Mutex
互斥锁有两个方法
func (m *Mutex) Lock() // 加锁
func (m *Mutex) Unlock() // 解锁
一个互斥锁只能同时被一个 goroutine 锁定，其它 goroutine 将阻塞直到互斥锁被解锁才能加锁成功。 sync.Mutex 在使用的时候要注意： 对一个未锁定的互斥锁解锁将会产生运行时错误 。 对上面的例子稍作修改，加上互斥锁：
package main
import (
"fmt"
"sync"
)
var (
num int
wg = sync.WaitGroup{}
// 我们用锁来保证num的并发安全
mu = sync.Mutex{}
)
func add() {
mu.Lock()
defer wg.Done()
num += 1
mu.Unlock()
}
func main() {
var n = 10 * 10 * 10 * 10
wg.Add(n)
for i := 0; i < n; i++ {
// 启动n个goroutine去累加num
go add()
}
// 等待所有goroutine执行完毕
wg.Wait()
fmt.Println(num == n)
}
运行结果：
true
我们可以自行修改n的值，在我们能开启足够多的 goroutine 的情况下，他结果一定会是 true 。 本例使用了前面介绍的 sync.WaitGroup 来等待所有协程执行结束。并且在 add 函数里使用了互斥锁来保证 num += 1 操作的并发安全，但是注意不要忘了用 mu.Unlock 来进行解锁，否则其他 goroutine 将一直等待加锁造成阻塞。 3.1.2 读写锁RWMutex 读写锁就是将读操作和写操作分开，可以分别对读和写进行加锁，一般用在大量读操作、少量写操作的情况。 读写锁的声明方式如下：
var rw sync.RWMutex
读写锁有两个方法：
func (rw *RWMutex) Lock() // 对写锁加锁
func (rw *RWMutex) Unlock() // 对写锁解锁
func (rw *RWMutex) RLock() // 对读锁加锁
func (rw *RWMutex) RUnlock() // 对读锁解锁
读写锁的使用遵循以下几个法则： 同时只能有一个 goroutine 能够获得写锁定。 同时可以有任意多个 gorouinte 获得读锁定。 同时只能存在写锁定或读锁定（读和写互斥）。 通俗理解就是可以多个 goroutine 同时读，但是只有一个 goroutine 能写，共享资源要么在被一个或多个 goroutine 读取，要么在被一个 goroutine 写入， 读写不能同时进行。 读写锁示例：
package main
import (
"fmt"
"sync"
"time"
)
var cnt = 0
func main() {
var mr sync.RWMutex
for i := 1; i <= 3; i++ {
go write(&mr, i)
}
for i := 1; i <= 3; i++ {
go read(&mr, i)
}
time.Sleep(time.Second)
fmt.Println("final count:", cnt)
}
func read(mr *sync.RWMutex, i int) {
fmt.Printf("goroutine%d reader start\n", i)
mr.RLock()
fmt.Printf("goroutine%d reading count:%d\n", i, cnt)
time.Sleep(time.Millisecond)
mr.RUnlock()
fmt.Printf("goroutine%d reader over\n", i)
}
func write(mr *sync.RWMutex, i int) {
fmt.Printf("goroutine%d writer start\n", i)
mr.Lock()
cnt++
fmt.Printf("goroutine%d writing count:%d\n", i, cnt)
time.Sleep(time.Millisecond)
mr.Unlock()
fmt.Printf("goroutine%d writer over\n", i)
}
运行结果：
goroutine3 reader start
goroutine3 reading count:0
goroutine1 writer start
goroutine2 writer start
goroutine1 reader start
goroutine2 reader start
goroutine3 writer start
goroutine3 reader over
goroutine1 writing count:1
goroutine1 writer over
goroutine1 reading count:1
goroutine2 reading count:1
goroutine2 reader over
goroutine2 writing count:2
goroutine1 reader over
goroutine2 writer over
goroutine3 writing count:3
goroutine3 writer over
final count: 3
简单分析：首先 goroutine3 开始加了读锁，开始读取，读到count的值为0，然后 goroutine1 尝试写入， goroutine2 尝试写入，但是都会阻塞，因为 goroutine3 加了读锁，不能再加写锁，在第8行 goroutine3 读取完毕之后， goroutine1 争抢到了锁，加了写锁，写完释放写锁之后， goroutine1 和 goroutine2 同时加了读锁，读到count的值为1。可以看到读写锁是互斥的，写写锁是互斥的，读读锁可以一起加。 3.1.3 死锁 提到锁，就有一个绕不开的话题：死锁。死锁就是一种状态，当两个或以上的 goroutine 在执行过程中，因争夺共享资源处在互相等待的状态，如果没有外部干涉将会一直处于这种阻塞状态，我们称这时的系统发生了死锁。思索场景一般有以下两种 Lock/Unlock不成对 。这类情况最常见的场景就是对锁进行拷贝使用
package main
import (
"fmt"
"sync"
)
func main() {
var mu sync.Mutex
mu.Lock()
defer mu.Unlock()
copyMutex(mu)
}
func copyMutex(mu sync.Mutex) {
mu.Lock()
defer mu.Unlock()
fmt.Println("ok")
}
运行结果：
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [semacquire]:
sync.runtime_SemacquireMutex(0xc0000160ac, 0x0, 0x1)
D:/Program Files/Go/src/runtime/sema.go:71 +0x4e
sync.(*Mutex).lockSlow(0xc0000160a8)
D:/Program Files/Go/src/sync/mutex.go:138 +0x10f
sync.(*Mutex).Lock(...)
D:/Program Files/Go/src/sync/mutex.go:81
main.copyTest(0xc0000160a8)
会报死锁，为什么呢？有的同学可能会注意到，这里 mu sync.Mutex 当作参数传入到函数 copyMutex ，锁进行了拷贝，不是原来的锁变量了，那么一把新的锁，在执行 mu.Lock() 的时候应该没问题。这就是要注意的地方，如果将带有锁结构的变量赋值给其他变量，锁的状态会复制。所以多锁复制后的新的锁拥有了原来的锁状态，那么在 copyMutex 函数内执行 mu.Lock() 的时候会一直阻塞，因为外层的 main 函数已经 Lock() 了一次，但是并没有机会 Unlock() ，导致内层函数会一直等待 Lock() ，而外层函数一直等待 Unlock() ，这样就造成了死锁 所以在使用锁的时候，我们应当尽量避免锁拷贝，并且保证Lock()和Unlock()成对出现，没有成对出现容易会出现死锁的情况，或者是Unlock 一个未加锁的Mutex而导致 panic。尽量养成如下使用习惯
mu.Lock()
defer mu.Unlock()
循环等待 另一个容易造成死锁的场景就是循环等待，A等B，B等C，C等A，循环等待
package main
import (
"sync"
"time"
)
func main() {
var mu1, mu2 sync.Mutex
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
mu1.Lock()
defer mu1.Unlock()
time.Sleep(1 * time.Second)
mu2.Lock()
defer mu2.Unlock()
}()
go func() {
defer wg.Done()
mu2.Lock()
defer mu2.Unlock()
time.Sleep(1 * time.Second)
mu1.Lock()
defer mu1.Unlock()
}()
wg.Wait()
}
运行结果：
fatal error: all goroutines are asleep - deadlock!
死锁了，代码很简单，两个 goroutine ，一个 goroutine 先锁 mu1 ，再锁 mu2 ，另一个 goroutine 先锁 mu2 ，再锁 mu1 ，但是在它们进行第二次枷锁操作的时候，彼此等待对方释放锁，这样就造成了循环等待，一直阻塞，形成死锁。 4. sync.Map Go语言内置的Map并不是并发安全的，在多个 goroutine 同时操作map的时候，会有并发问 具体看下面例子
package main
import (
"fmt"
"strconv"
"sync"
)
var m = make(map[string]int)
func getVal(key string) int {
return m[key]
}
func setVal(key string, value int) {
m[key] = value
}
func main() {
wg := sync.WaitGroup{}
wg.Add(10)
for i := 0; i < 10; i++ {
go func(num int) {
defer wg.Done()
key := strconv.Itoa(num)
setVal(key, num)
fmt.Printf("key=:%v,val:=%v\n", key, getVal(key))
}(i)
}
wg.Wait()
}
运行结果：
fatal error: concurrent map writes
程序报错了，说明 map 不能同时被多个 goroutine 读写。要解决 map 的并发写问题一种方式使用我们前面学到的对 map 加锁，这样就可以了
package main
import (
"fmt"
"strconv"
"sync"
)
var m = make(map[string]int)
var mu sync.Mutex
func getVal(key string) int {
return m[key]
}
func setVal(key string, value int) {
m[key] = value
}
func main() {
wg := sync.WaitGroup{}
wg.Add(10)
for i := 0; i < 10; i++ {
go func(num int) {
defer func() {
wg.Done()
mu.Unlock()
}()
key := strconv.Itoa(num)
mu.Lock()
setVal(key, num)
fmt.Printf("key=:%v,val:=%v\n", key, getVal(key))
}(i)
}
wg.Wait()
}
运行结果：
key=:9,val:=9
key=:4,val:=4
key=:0,val:=0
key=:1,val:=1
key=:2,val:=2
key=:3,val:=3
key=:6,val:=6
key=:7,val:=7
key=:5,val:=5
key=:8,val:=8
另外一种方式是使用 sync 包中提供的一个开箱即用的并发安全版 map – sync.Map ,在 Go 1.9 引入。 sync.Map 不用初始化就可以使用，同时 sync.Map 内置了诸如 Store 、 Load 、 LoadOrStore 、 Delete 、 Range 等操作方法。 具体使用方法看示例：
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map
// 1. 写入
m.Store("name", "zhangsan")
m.Store("age", 18)
// 2. 读取
age, _ := m.Load("age")
fmt.Println(age.(int))
// 3. 遍历
m.Range(func(key, value interface{}) bool {
fmt.Printf("key is:%v, val is:%v\n", key, value)
return true
})
// 4. 删除
m.Delete("age")
age, ok := m.Load("age")
fmt.Println(age, ok)
// 5. 读取或写入
m.LoadOrStore("name", "zhangsan")
name, _ := m.Load("name")
fmt.Println(name)
}
运行结果：
18
key is:name, val is:zhangsan
key is:age, val is:18
<nil> false
zhangsan
通过store方法写入两个键值对 读取key为age的值，读出来age为18 通过range方法遍历map的key和value 删除key为age的键值对，删除完之后，再次读取age，age为空，ok为false表示map里没有这个key LoadOrStore尝试读取key为name的值，读取不到就写入键值对name-zhangsan，能读取到就返回原来map里的name对应的值 注意： sync.Map 没有提供获取 map 数量的方法，需要我们在对 sync.Map 进行遍历时自行计算， sync.Map 为了保证并发安全有一些性能损失，因此在非并发情况下，使用 map 相比使用 sync.Map 会有更好的性能 5. sync/Atomic 除了前面介绍的锁 mutex 以外，还有一种解决并发安全的策略，就是原子操作。所谓原子操作就是这一系列的操作在 cpu 上执行是一个不可分割的整体，显然要么全部执行，要么全部不执行，不会受到其他操作的影响，也就不会存在并发问题。 5.1 atomic和mutex的区别 使用方式：通常 mutex 用于保护一段执行逻辑，而 atomic 主要是对变量进行操作 底层实现： mutex 由操作系统调度器实现，而 atomic 操作有底层硬件指令支持，保证在 cpu 上执行不中断。所以 atomic 的性能也能随 cpu 的个数增加线性提升 5.1.1 atomic 提供的方法：
func AddT(addr *T, delta T)(new T)
func StoreT(addr *T, val T)
func LoadT(addr *T) (val T)
func SwapT(addr *T, new T) (old T)
func CompareAndSwapT(addr *T, old, new T) (swapped bool)
T的类型是int32、int64、uint32、uint64和uintptr中的任意一种
这里就不一一演示各个方法了，以 AddT 方法为例简单看一个例子
package main
import (
"fmt"
"sync"
"sync/atomic"
)
func main() {
var sum int32 = 0
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
atomic.AddInt32(&sum, 1)
}()
}
wg.Wait()
fmt.Printf("sum is %d\n",sum)
}
100个goroutine，每个goroutine都对sum+1，最后结果为100。 5.2 atomic.value 上面展示的 AddT ， StoreT 等方法都是针对的基本数据类型做的操作，假设想对多个变量进行同步保护，即假设想对一个 struct 这样的复合类型用原子操作，也是支持的吗？也可以做支持，go语言里的 atomic.value 支持任意一种接口类型进行原子操作，且提供了 Load 、 Store 、 Swap 和 CompareAndSwap 四种方法： Load ：func (v *Value) Load() (val any)，从value读出数据 Store ：func (v *Value) Store(val any)，向value写入数据 Swap ：func (v *Value) Swap(new any) (old any)，用new交换value中存储的数据，返回value原来存储的旧数据 CompareAndSwap ：func (v *Value) CompareAndSwap(old, new any) (swapped bool)，比较value中存储的数据和old是否相同，相同的话，将value中的数据替换为new 代码示例
package main
import (
"fmt"
"sync/atomic"
)
type Student struct {
Name string
Age int
}
func main() {
st1 := Student{
Name: "zhangsan",
Age: 18,
}
st2 := Student{
Name: "lisi",
Age: 19,
}
st3 := Student{
Name: "wangwu",
Age: 20,
}
var v atomic.Value
v.Store(st1)
fmt.Println(v.Load().(Student))
old := v.Swap(st2)
fmt.Printf("after swap: v=%v\n", v.Load().(Student))
fmt.Printf("after swap: old=%v\n", old)
swapped := v.CompareAndSwap(st1, st3) // v中存储的和st1不相同，交换失败
fmt.Println("compare st1 and v\n", swapped, v)
swapped = v.CompareAndSwap(st2, st3) // v中存储的和st2相同，交换成功，v中变为st3
fmt.Println("compare st2 and v\n", swapped, v)
}
运行结果
{zhangsan 18}
after swap: v={lisi 19}
after swap: old={zhangsan 18}
compare st1 and v
false {{lisi 19}}
compare st2 and v
true {{wangwu 20}}
- sync.pool sync.Pool 是在 sync 包下的一个内存池组件，用来实现对象的复用，避免重复创建相同的对象，造成频繁的内存分配和gc，以达到提升程序性能的目的。虽然池子中的对象可以被复用，但是是 sync.Pool 并不会永久保存这个对象，池子中的对象会在一定时间后被gc回收，这个时间是随机的。所以，用 sync.Pool 来持久化存储对象是不可取的。 另外， sync.Pool 本身是并发安全的，支持多个 goroutine 并发的往 sync.Pool 存取数据 6.1 sync.pool使用方法 关于 sync.Pool 的使用，一般是通过三个方法来完成的 方法 说明 New() sync.Pool的构造函数，用于指定sync.Pool中缓存的数据类型，当调用Get方法从对象池中获取对象的时候，对象池中如果没有，会调用New方法创建一个新的对象 Get() 从对象池取对象 Put() 往对象池放对象，下次Get的时候可以复用 下面通过例子看一下 sync.Pool 的使用方式
package main
import (
"fmt"
"sync"
)
type Student struct {
Name string
Age int
}
func main() {
pool := sync.Pool{
New: func() interface{} {
return &Student{
Name: "zhangsan",
Age: 18,
}
},
}
st := pool.Get().(*Student)
println(st.Name, st.Age)
fmt.Printf("addr is %p\n", st)
pool.Put(st)
st1 := pool.Get().(*Student)
println(st1.Name, st1.Age)
fmt.Printf("addr1 is %p\n", st1)
}
程序输出
zhangsan 18
addr is 0x140000a0018
zhangsan 18
addr1 is 0x140000a0018
在程序中，首先初始化一个 sync.Pool 对象，初始化里面的 New 方法，用于创建对象，这里是返回一个 Student 类型的指针。第一次调用 pool.Get().(*Student) 的时候，由于池子内没有对象，所以会通过 New 方法创建一个，注意 pool.Get() 返回的是一个 interface{} ，所以我们需要断言成 *Student 类型，在我们使用完，打印出 Name 和 Age 之后，再调用 Put 方法，将这个对象放回到池子内，后面我们紧接着又调用 pool.Get() 取对象，可以看到两次去除的对象地址是同一个，说明是同一个对象，表明 sync.Pool 有缓存对象的功能。 注意 我们在第一次 pool.Get() 取出 *Student 对象打印完地址之后，put进池子的时候没有进行一个Reset的过程，这里是因为我们取出 *Student 对象之后，仅仅是读取里面的字段，并没有修改操作，假设我们有修改操作，那么这里就需要在 pool.Put(st) 之前执行 Reset ，将对象的值复原，如果不这样做，那么下一次 pool.Get() 取出的 *Student 对象就不是我们希望复用的初始对象 假设我们对 *Student 做修改
package main
import (
"fmt"
"sync"
)
type Student struct {
Name string
Age int
}
func main() {
pool := sync.Pool{
New: func() interface{} {
return &Student{
Name: "zhangsan",
Age: 18,
}
},
}
st := pool.Get().(*Student)
println(st.Name, st.Age)
fmt.Printf("addr is %p\n", st)
// 修改
st.Name = "lisi"
st.Age = 20
// 回收
pool.Put(st)
st1 := pool.Get().(*Student)
println(st1.Name, st1.Age)
fmt.Printf("addr1 is %p\n", st1)
}
程序输出
zhangsan 18
addr is 0x1400000c030
lisi 20
addr1 is 0x1400000c030
可以看到，我们第二次取出的对象虽然和第一次是同一个，地址形同，但是对象的字段值却发生了变化，不是我们初始化的对象了，我们想要一只重复使用一个相同的对象的话，显然这里有问题。所以，我们需要在 pool.Put(st) 回收对象之前，进行对象的 Reset 操作，将对象值复原，同时在每次我们 pool.Get() 取出完对象使用完毕之后，也不要忘了调用 pool.Put 方法把对象再次放入对象池，以便对象能够复用。 6.2 sync.pool使用场景 sync.pool 主要是通过对象复用来降低gc带来的性能损耗，所以在高并发场景下，由于每个 goroutine 都可能过于频繁的创建一些大对象，造成gc压力很大。所以在高并发业务场景下出现 GC 问题时，可以使用 sync.Pool 减少 GC 负担 sync.pool 不适合存储带状态的对象，比如socket 连接、数据库连接等，因为里面的对象随时可能会被gc回收释放掉 不适合需要控制缓存对象个数的场景，因为 Pool 池里面的对象个数是随机变化的，因为池子里的对象是会被gc的，且释放时机是随机的 关注秀才公众号： IT杨秀才 ，领取精品学习资料 公众号后台回复： Go面试 ，领取Go面试题库PDF 公众号后台回复： Go学习 ，领取Go必看书籍 公众号后台回复： 大模型 ，领取大模型学习资料 公众号后台回复： 111 ，领取架构学习资料 公众号后台回复： 26届秋招 ，领取26届秋招企业汇总表
🔥 配套实战项目，拆得开、跑得起、能写进简历 多 Agent 编排 + RAG 混合检索 · 31 篇深度教程 + 50+ 面试题 点击查看 DevSupport AI 实战项目 → 在 GitHub 上编辑此页 上次编辑于: 2026/6/24 23:41:22 贡献者: Percygu , Your Name , gupeng 上一页 3. Channel 下一页 5. Select