深刻Golang之sync.Pool详解

咱们一般用golang来构建高并发场景下的应用，可是因为golang内建的GC机制会影响应用的性能，为了减小GC，golang提供了对象重用的机制，也就是sync.Pool对象池。 sync.Pool是可伸缩的，并发安全的。其大小仅受限于内存的大小，能够被看做是一个存放可重用对象的值的容器。 设计的目的是存放已经分配的可是暂时不用的对象，在须要用到的时候直接从pool中取。

任何存放区其中的值能够在任什么时候候被删除而不通知，在高负载下能够动态的扩容，在不活跃时对象池会收缩。

sync.Pool首先声明了两个结构体

// Local per-P Pool appendix.
type poolLocalInternal struct {
	private interface{}   // Can be used only by the respective P.
	shared  []interface{} // Can be used by any P.
	Mutex                 // Protects shared.
}

type poolLocal struct {
	poolLocalInternal

	// Prevents false sharing on widespread platforms with
	// 128 mod (cache line size) = 0 .
	pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
}

为了使得在多个goroutine中高效的使用goroutine，sync.Pool为每一个P(对应CPU)都分配一个本地池，当执行Get或者Put操做的时候，会先将goroutine和某个P的子池关联，再对该子池进行操做。 每一个P的子池分为私有对象和共享列表对象，私有对象只能被特定的P访问，共享列表对象能够被任何P访问。由于同一时刻一个P只能执行一个goroutine，因此无需加锁，可是对共享列表对象进行操做时，由于可能有多个goroutine同时操做，因此须要加锁。

值得注意的是poolLocal结构体中有个pad成员，目的是为了防止false sharing。cache使用中常见的一个问题是false sharing。当不一样的线程同时读写同一cache line上不一样数据时就可能发生false sharing。false sharing会致使多核处理器上严重的系统性能降低。具体的能够参考伪共享(False Sharing)。

类型sync.Pool有两个公开的方法，一个是Get，一个是Put, 咱们先来看一下Put的源码。

// Put adds x to the pool.
func (p *Pool) Put(x interface{}) {
	if x == nil {
		return
	}
	if race.Enabled {
		if fastrand()%4 == 0 {
			// Randomly drop x on floor.
			return
		}
		race.ReleaseMerge(poolRaceAddr(x))
		race.Disable()
	}
	l := p.pin()
	if l.private == nil {
		l.private = x
		x = nil
	}
	runtime_procUnpin()
	if x != nil {
		l.Lock()
		l.shared = append(l.shared, x)
		l.Unlock()
	}
	if race.Enabled {
		race.Enable()
	}
}

1. 若是放入的值为空，直接return.
2. 检查当前goroutine的是否设置对象池私有值，若是没有则将x赋值给其私有成员，并将x设置为nil。
3. 若是当前goroutine私有值已经被设置，那么将该值追加到共享列表。

func (p *Pool) Get() interface{} {
	if race.Enabled {
		race.Disable()
	}
	l := p.pin()
	x := l.private
	l.private = nil
	runtime_procUnpin()
	if x == nil {
		l.Lock()
		last := len(l.shared) - 1
		if last >= 0 {
			x = l.shared[last]
			l.shared = l.shared[:last]
		}
		l.Unlock()
		if x == nil {
			x = p.getSlow()
		}
	}
	if race.Enabled {
		race.Enable()
		if x != nil {
			race.Acquire(poolRaceAddr(x))
		}
	}
	if x == nil && p.New != nil {
		x = p.New()
	}
	return x
}

1. 尝试从本地P对应的那个本地池中获取一个对象值, 并从本地池冲删除该值。
2. 若是获取失败，那么从共享池中获取, 并从共享队列中删除该值。
3. 若是获取失败，那么从其余P的共享池中偷一个过来，并删除共享池中的该值(p.getSlow())。
4. 若是仍然失败，那么直接经过New()分配一个返回值，注意这个分配的值不会被放入池中。New()返回用户注册的New函数的值，若是用户未注册New，那么返回nil。

 

最后咱们来看一下init函数。

func init() {
    runtime_registerPoolCleanup(poolCleanup)
}

能够看到在init的时候注册了一个PoolCleanup函数，他会清除掉sync.Pool中的全部的缓存的对象，这个注册函数会在每次GC的时候运行，因此sync.Pool中的值只在两次GC中间的时段有效。

 

package main

import (
    "sync"
    "time"
    "fmt"
)

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


func main()  {
    //defer
    //debug.SetGCPercent(debug.SetGCPercent(-1))
    a := time.Now().Unix()
    for i:=0;i<1000000000;i++{
        obj := make([]byte, 1024)
        _ = obj
    }
    b := time.Now().Unix()

    for j:=0;j<1000000000;j++  {
        obj := bytePool.Get().(*[]byte)
        _ = obj
        bytePool.Put(obj)
    }

    c := time.Now().Unix()
    fmt.Println("without pool ", b - a, "s")
    fmt.Println("with    pool ", c - b, "s")
}

可见GC对性能影响不大，由于shared list太长也会耗时。

 

总结：

经过以上的解读，咱们能够看到，Get方法并不会对获取到的对象值作任何的保证，由于放入本地池中的值有可能会在任什么时候候被删除，可是不通知调用者。放入共享池中的值有可能被其余的goroutine偷走。 因此对象池比较适合用来存储一些临时切状态无关的数据，可是不适合用来存储数据库链接的实例，由于存入对象池重的值有可能会在垃圾回收时被删除掉，这违反了数据库链接池创建的初衷。

根据上面的说法，Golang的对象池严格意义上来讲是一个临时的对象池，适用于储存一些会在goroutine间分享的临时对象。主要做用是减小GC，提升性能。在Golang中最多见的使用场景是fmt包中的输出缓冲区。

在Golang中若是要实现链接池的效果，能够用container/list来实现，开源界也有一些现成的实现，好比go-commons-pool，具体的读者能够去自行了解。

 

参考资料：

• go语言的官方包sync.Pool的实现原理和适用场景
• sync.Pool源码