临时对象存储池

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

官方文档可以看这里 http://golang.org/pkg/sync/#Pool

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

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

Get 返回 Pool 中的任意一个对象。

如果 Pool 为空，则调用 New 返回一个新创建的对象。

如果没有设置 New，则返回 nil。

还有一个重要的特性是，放进 Pool 中的对象，会在说不准什么时候被回收掉。

所以如果事先 Put 进去 100 个对象，下次 Get 的时候发现 Pool 是空也是有可能的。

不过这个特性的一个好处就在于不用担心 Pool 会一直增长，因为 Go 已经帮你在 Pool 中做了回收机制。

这个清理过程是在每次垃圾回收之前做的。垃圾回收是固定两分钟触发一次。

而且每次清理会将 Pool 中的所有对象都清理掉！

package main
 
import(
    "sync"
    "log"
)
 
func main(){
    // 建立对象
    var pipe = &sync.Pool{
        New : func()interface{}{
            return "Hello, BeiJing"
        }
    }
     
    // 准备放入的字符串
    val := "Hello,World!"
     
    // 放入
    pipe.Put(val)
     
    // 取出
    log.Println(pipe.Get())
     
    // 再取就没有了,会自动调用NEW
    log.Println(pipe.Get())
}
 
/* 输出
2014/09/30 15:43:30 Hello, World!
2014/09/30 15:43:30 Hello, BeiJing
*/

例子

package main

import (
	"fmt"
	"sync"
)

const MAX_LEN int = 200
var arrPool = &sync.Pool{  //使用对象池，避免频繁地申请/释放大内存
	New: func() interface{} {
		return make([]uint32, 0, MAX_LEN)
	},
}

func fn1(j int) []uint32 {
	arr := arrPool.Get().([]uint32)
	for i := 0; i < 10; i++ {
		arr = append(arr, uint32(i)*uint32(j+1))
	}
	return arr[:10]
}
func main() {
	bu1 := make([][]uint32, 20)
	wg := sync.WaitGroup{}
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			bu1[i] = fn1(i)
		}(i)
	}
	wg.Wait()
	for _, v := range bu1 {
		fmt.Println(v)
		arrPool.Put(v)
	}
}
/*
[0 1 2 3 4 5 6 7 8 9]
[0 2 4 6 8 10 12 14 16 18]
[0 3 6 9 12 15 18 21 24 27]
[0 4 8 12 16 20 24 28 32 36]
[0 5 10 15 20 25 30 35 40 45]
[0 6 12 18 24 30 36 42 48 54]
[0 7 14 21 28 35 42 49 56 63]
[0 8 16 24 32 40 48 56 64 72]
[0 9 18 27 36 45 54 63 72 81]
[0 10 20 30 40 50 60 70 80 90]
[0 11 22 33 44 55 66 77 88 99]
[0 12 24 36 48 60 72 84 96 108]
[0 13 26 39 52 65 78 91 104 117]
[0 14 28 42 56 70 84 98 112 126]
[0 15 30 45 60 75 90 105 120 135]
[0 16 32 48 64 80 96 112 128 144]
[0 17 34 51 68 85 102 119 136 153]
[0 18 36 54 72 90 108 126 144 162]
[0 19 38 57 76 95 114 133 152 171]
[0 20 40 60 80 100 120 140 160 180]
*/