Go语言sync.Pool（线程池）使用

前言

Go 1.3 的sync包中加入一个新特性：Pool。

这个类设计的目的是用来保存和复用临时对象，以减少内存分配，降低CG压力。

1 2 3 4

type Pool func (p *Pool) Get() interface{} func (p *Pool) Put(x interface{}) New func() interface{}

1、基本使用：

（1）简单的数据存储。如果没有数据，返回线程池指定的数据。

package main

import (
	"fmt"
	"sync"
)
func main() {
	p:=&sync.Pool{
		New: func() interface{}{
			return 0
		},
	}
	p.Put("jiangzhou")
	p.Put(123456)
	fmt.Println(p.Get())
	fmt.Println(p.Get())
	fmt.Println(p.Get())
}

2、处理临时变量

垃圾回收一直是Go语言的一块心病，在它执行垃圾回收的时间中，你很难做什么。

在垃圾回收压力大的服务中，GC占据的CPU有可能超过2%，造成的Pause经常超过2ms。垃圾严重的时候，秒级的GC也出现过。

如果经常临时使用一些大型结构体，可以用Pool来减少GC。

package main
import (
	"sync"
	"time"
	"fmt"
)

type structR6 struct {
	B1 [100000]int
}
var r6Pool = sync.Pool{
	New: func() interface{} {
		return new(structR6)
	},
}
func usePool() {
	startTime := time.Now()
	for i := 0; i < 10000; i++ {
		sr6 := r6Pool.Get().(*structR6)
		sr6.B1[0] = 0
		r6Pool.Put(sr6)
	}
	fmt.Println("pool Used:", time.Since(startTime))
}
func standard() {
	startTime := time.Now()
	for i := 0; i < 10000; i++ {
		var sr6 structR6
		sr6.B1[0] = 0
	}
	fmt.Println("standard Used:", time.Since(startTime))
}
func main() {
	standard()
	usePool()
}

一个含有100000个int值的结构体，在标准方法中，每次均新建，重复10000次，一共需要耗费188.4969ms；

如果用完的struct可以废物利用，放回pool中。需要新的结构体的时候，尝试去pool中取，而不是重新生成，重复10000次仅需要997.8us。

这样简单的操作，却节约了99.65%的时间，也节约了各方面的资源。最重要的是它可以有效减少GC CPU和GC Pause。

（2）用途

• sync.Pool是一个可以存或取的临时对象集合

• sync.Pool可以安全被多个线程同时使用，保证线程安全

• 注意、注意、注意，sync.Pool中保存的任何项都可能随时不做通知的释放掉，所以不适合用于像socket长连接或数据库连接池。

• sync.Pool主要用途是增加临时对象的重用率，减少GC负担。

func main() {
	//我们创建一个Pool，并实现New()函数
	sp := sync.Pool{
		//New()函数的作用是当我们从Pool中Get()对象时，如果Pool为空，则先通过New创建一个对象，插入Pool中，然后返回对象。
		New: func() interface{} {
			return make([]int, 16)
		},
	}
	item := sp.Get()
	//打印可以看到，我们通过New返回的大小为16的[]int
	fmt.Println("item : ", item)

	//然后我们对item进行操作
	//New()返回的是interface{}，我们需要通过类型断言来转换
	for i := 0; i < len(item.([]int)); i++ {
		item.([]int)[i] = i
	}
	fmt.Println("item : ", item)

	//使用完后，我们把item放回池中，让对象可以重用
	sp.Put(item)

	//再次从池中获取对象
	item2 := sp.Get()
	//注意这里获取的对象就是上面我们放回池中的对象
	fmt.Println("item2 : ", item2)
	//我们再次获取对象
	item3 := sp.Get()
	//因为池中的对象已经没有了，所以又重新通过New()创建一个新对象，放入池中，然后返回
	//所以item3是大小为16的空[]int
	fmt.Println("item3 : ", item3)

	//测试sync.Pool保存socket长连接池
	//testTcpConnPool()
}

注意、注意、注意，sync.Pool中保存的任何项都可能随时不做通知的释放掉，所以不适合用于像socket长连接或数据库连接池，如下图所示。

package main

import (
	"sync"
	"net"
	"fmt"
	"runtime"
)

func main() {
	sp2 := sync.Pool{
		New: func() interface{} {
			conn, err := net.Dial("tcp", "127.0.0.1:8888");
			if err != nil {
				return nil
			}
			return conn
		},
	}
	buf := make([]byte, 1024)
	//获取对象
	conn := sp2.Get().(net.Conn)
	//使用对象
	conn.Write([]byte("GET / HTTP/1.1 \r\n\r\n"))
	n, _ := conn.Read(buf)
	fmt.Println("conn read : ", string(buf[:n]))
	//打印conn的地址
	fmt.Println("coon地址：",conn)
	//把对象放回池中
	sp2.Put(conn)
	//我们人为的进行一次垃圾回收
	runtime.GC()
	//再次获取池中的对象
	conn2 := sp2.Get().(net.Conn)
	//这时发现conn2的地址与上面的conn的地址不一样了
	//说明池中我们之前放回的对象被全部清除了，显然这并不是我们想看到的
	//所以sync.Pool不适合用于scoket长连接或数据库连接池
	fmt.Println("coon2地址",conn2)
}

➢了解更多Go语言知识：https://study.163.com/course/introduction/1210620804.htm