临时对象存储池

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]
*/