sync.Pool 的作用
sync.Pool 是 Go 语言中的一个对象池，用于存储和复用一些可以被重复利用的对象，从而减少对象的创建和垃圾回收的压力。 sync.Pool 可以在一定程度上提高程序的性能，特别是在需要频繁创建和销毁对象的场景中，例如网络编程、数据库连接池等。
sync.Pool 的使用
sync.Pool 的使用非常简单，只需要创建一个 sync.Pool 对象，并实现两个方法：
- Get()：从对象池中获取一个对象，如果对象池为空，则返回一个新的对象。
- Put()：将一个不再使用的对象放回到对象池中，以便复用。 下面是一个简单的例子，演示了如何使用 sync.Pool 对象池存储和复用字符串对象：
package main
import (
"fmt"
"sync"
)
func main() {
pool := sync.Pool{
New: func() interface{} {
return ""
},
}
str := pool.Get().(string)
fmt.Println(str)
str = "Hello, World!"
pool.Put(str)
str = pool.Get().(string)
fmt.Println(str)
}
在上面的例子中，我们创建了一个 sync.Pool 对象，并指定其 New 方法返回一个空字符串。然后我们从对象池中获取一个字符串对象，由于对象池为空，因此会创建一个新的字符串对象。接着我们将一个字符串对象放回到对象池中，并再次从对象池中获取一个字符串对象，由于对象池中已经有了一个字符串对象，因此不需要再创建新的对象。 除了存储和复用字符串对象之外，sync.Pool 还可以存储和复用其他类型的对象，例如结构体、字节数组等。
sync.Pool 的使用场景
sync.Pool 在以下场景中特别有用：
- 对象的创建和销毁比较耗时，例如网络编程中的连接池、数据库连接池等。
- 需要频繁创建和销毁对象的场景，例如在循环中创建和销毁临时对象等。 需要注意的是，由于 sync.Pool 对象池的特性，其中存储的对象并不会被垃圾回收器自动回收。因此，如果对象池中存储的对象占用过多的内存，需要通过其他方式释放这些对象，例如在程序的某个时刻调用 sync.Pool 对象池的 Clean 方法清空所有对象。
避免频繁创建和销毁 goroutine
在 Go 语言中，创建和销毁 goroutine 的成本比较高，因此在需要并发处理大量任务的场景中，可以使用 sync.Pool 对象池来避免频繁创建和销毁 goroutine。
package main
import (
"fmt"
"sync"
)
func main() {
pool := sync.Pool{
New: func() interface{} {
ch := make(chan int)
go func() {
for {
select {
case <-ch:
return
default:
fmt.Println("worker is working")
}
}
}()
return ch
},
}
ch := pool.Get().(chan int)
ch <- 1
ch <- 2
pool.Put(ch)
ch = pool.Get().(chan int)
ch <- 3
ch <- 4
pool.Put(ch)
ch = pool.Get().(chan int)
ch <- 5
ch <- 6
pool.Put(ch)
ch = pool.Get().(chan int)
ch <- 7
ch <- 8
pool.Put(ch)
ch = pool.Get().(chan int)
ch <- 9
ch <- 10
pool.Put(ch)
}
在上述例子中，我们创建了一个 sync.Pool 对象池，并指定其 New 方法返回一个可以不断循环工作的 goroutine。然后我们从对象池中获取一个 goroutine，并向其发送一些消息。接着我们将这个 goroutine 放回对象池中，以便复用。这样，我们就避免了频繁创建和销毁 goroutine 的成本。
减少内存分配
在 Go 语言中，内存分配的成本比较高，因此在需要频繁创建和销毁对象的场景中，可以使用 sync.Pool 对象池来减少内存分配的成本。
package main
import (
"fmt"
"sync"
)
type Object struct {
data [1024]byte
}
func main() {
pool := sync.Pool{
New: func() interface{} {
return new(Object)
},
}
for i := 0; i < 1000000; i++ {
obj := pool.Get().(*Object)
obj.data[0] = 1
pool.Put(obj)
}
fmt.Println("Done")
}
在上述例子中，我们创建了一个 sync.Pool 对象池，并指定其 New 方法返回一个 Object 对象。然后我们从对象池中获取一个 Object 对象，并向其写入一些数据。接着我们将这个 Object 对象放回对象池中，以便复用。这样，我们就减少了频繁创建和销毁 Object 对象的内存分配成本。
以下是一个简单的 sync.Pool 函数的封装示例：
package main
import (
"fmt"
"sync"
)
type PoolHelper struct {
pool sync.Pool
}
func (p *PoolHelper) Get() interface{} {
return p.pool.Get()
}
func (p *PoolHelper) Put(x interface{}) {
p.pool.Put(x)
}
func (p *PoolHelper) New(f func() interface{}) {
p.pool = sync.Pool{
New: f,
}
}
func main() {
var helper PoolHelper
helper.New(func() interface{} {
return make([]int, 0, 10)
})
s1 := helper.Get().([]int)
s2 := helper.Get().([]int)
helper.Put(s1)
helper.Put(s2)
s3 := helper.Get().([]int)
fmt.Println(len(s3))
}
在上述示例中，我们创建了一个 PoolHelper 结构体，并封装了 Get、Put 和 New 三个方法。使用 New 方法可以初始化一个 sync.Pool 对象池，并指定其 New 方法返回的对象类型。然后，我们可以使用 Get 方法从对象池中获取对象，并使用 Put 方法将对象放回对象池中。这样，我们就可以方便地使用 sync.Pool 对象池来减少对象的创建和销毁成本，提高程序的性能。
