gpool

对象复用池。将对象进行缓存复用，支持过期时间、创建方法及销毁方法定义。

使用场景：

任何需要对象(struct)复用的场景。

使用方式：

  1. import "gitee.com/johng/gf/g/container/gpool"

方法列表：godoc.org/github.com/johng-cn/gf/g/container/gpool

  1. type Pool
  2.     func New(expire int, newFunc ...func() (interface{}, error)) *Pool
  3.     func (p *Pool) Close()
  4.     func (p *Pool) Get() (interface{}, error)
  5.     func (p *Pool) Put(value interface{})
  6.     func (p *Pool) SetExpireFunc(expireFunc func(interface{}))
  7.     func (p *Pool) Size() int

需要注意两点：

  1. New方法的过期时间单位为毫秒；
  2. 对象创建方法(newFunc ...func() (interface{}, error))返回值包含一个error返回，当对象创建失败时可由该返回值反馈原因；

gpool与sync.Pool

gpool与sync.Pool的作用都是对象复用，但是sync.Pool的对象生命周期不支持开发者定义，因此也不确定，并且sync.Pool不支持对象创建方法及销毁方法。因此，gpool的功能更强大，并且更接近实战一些。

使用示例1，基本使用

  1. package main
  3. import (
  4.     "gitee.com/johng/gf/g/container/gpool"
  5.     "fmt"
  6.     "time"
  7. )
  9. func main () {
  10.     // 创建一个对象池，过期时间为1000毫秒
  11.     p := gpool.New(1000)
  13.     // 从池中取一个对象，返回nil及错误信息
  14.     fmt.Println(p.Get())
  16.     // 丢一个对象到池中
  17.     p.Put(1)
  19.     // 重新从池中取一个对象，返回1
  20.     fmt.Println(p.Get())
  22.     // 等待1秒后重试，发现对象已过期，返回nil及错误信息
  23.     time.Sleep(time.Second)
  24.     fmt.Println(p.Get())
  25. }

使用示例2，文件指针池

这个示例稍微复杂一些，但是却将gpool对象池的功能用得很完美。

该示例是一个gf框架的gfilepool文件指针池的实现源码。文件指针池和数据库连接池比较类似，是基于IO复用的一种设计。

一般的文件操作过程是这样的：当文件被打开之后，会创建一个文件指针，在文件操作结束后，文件指针就会被立即关闭掉。这样的话，在每一次操作或者请求中，对文件的操作都会反复创建/关闭指针，这样产生的问题：一个是操作效率比较低，另一个是系统的最大文件打开数是有限的，在文件操作频繁/访问量大的情况下，会影响整体系统的执行效率（文件锁，资源竞争），甚至引发一些严重的问题。文件指针池对于同一个文件在异步高并发下的读取性能提升非常大（因为读取不需要锁，每一个协程一个文件指针），但是对于写入性能的提升不大，因为文件写入往往都必须加锁以保证数据写入的顺序性。

  1. package gfilepool
  3. import (
  4.     "os"
  5.     "sync"
  6.     "gitee.com/johng/gf/g/container/gmap"
  7.     "gitee.com/johng/gf/g/container/gpool"
  8.     "fmt"
  9. )
  11. // 文件指针池
  12. type Pool struct {
  13.     pool    *gpool.Pool     // 底层对象池
  14. }
  16. // 文件指针池指针
  17. type File struct {
  18.     *os.File                // 底层文件指针
  19.     mu     sync.RWMutex     // 互斥锁
  20.     pool   *Pool            // 所属池
  21. }
  23. // 全局指针池，expire < 0表示不过期，expire = 0表示使用完立即回收，expire > 0表示超时回收
  24. var pools = gmap.NewStringInterfaceMap()
  26. // 获得文件对象，并自动创建指针池
  27. func OpenWithPool(path string, flag int, perm os.FileMode, expire int) (*File, error) {
  28.     key    := fmt.Sprintf("%s&%d&%d&%d", path, flag, expire, perm)
  29.     result := pools.Get(key)
  30.     if result != nil {
  31.         return result.(*Pool).File()
  32.     }
  33.     pool := New(path, flag, perm, expire)
  34.     pools.Set(key, pool)
  35.     return pool.File()
  36. }
  38. // 创建一个文件指针池，expire = 0表示不过期，expire < 0表示使用完立即回收，expire > 0表示超时回收
  39. func New(path string, flag int, perm os.FileMode, expire int) *Pool {
  40.     p     := &Pool {}
  41.     p.pool = gpool.New(expire, func() (interface{}, error) {
  42.         file, err := os.OpenFile(path, flag, perm)
  43.         if err != nil {
  44.             return nil, err
  45.         }
  46.         return &File{
  47.             File : file,
  48.             pool : p,
  49.         }, nil
  50.     })
  51.     p.pool.SetExpireFunc(func(i interface{}) {
  52.         i.(*File).File.Close()
  53.     })
  54.     return p
  55. }
  57. // 获得一个文件打开指针
  58. func (p *Pool) File() (*File, error) {
  59.     if v, err := p.pool.Get(); err != nil {
  60.         return nil, err
  61.     } else {
  62.         return v.(*File), nil
  63.     }
  64. }
  66. // 关闭指针池(返回error是标准库io.ReadWriteCloser接口实现)
  67. func (p *Pool) Close() error {
  68.     p.pool.Close()
  69.     return nil
  70. }
  72. // 获得底层文件指针(返回error是标准库io.ReadWriteCloser接口实现)
  73. func (f *File) Close() error {
  74.     f.pool.pool.Put(f)
  75.     return nil
  76. }