资源池模式是一种比较典型的应用模式,通过一个池子来管理资源,可以有效的降低不断创建新资源带来的资源开销,一般线程池都设置有固定大小的资源限制,同时池子也需要管理如何创建资源。下面是使用Go语言实现的一个资源池管理对象,所有资源满足io.Close方法也就是需要实现Close()方法即可,用于释放必要的资源对象。
type Pool struct {
mu sync.Mutex
resources chan io.Closer
factory func() (io.Closer, error)
closed bool
}
// ErrPoolClosed is returned when an Acquire returns on a
// closed pool.
var ErrPoolClosed = errors.New("Pool has been closed")
// New creates a pool that manages resources. A pool requires a
// function that can allocate a new resource and the size of
// the pool.
func New(size uint, f func() (io.Closer, error)) (*Pool, error) {
if size == 0 {
return nil, errors.New("Size value too small")
}
return &Pool{
factory: f,
resources: make(chan io.Closer, size),
}, nil
}
上面的锁用于实现并发安全的访问,多个Goroutine同时访问资源的时候,消除数据访问的冲突。
Pool需要实现的三个基本方法包含如下:
- Acquire 用于从池子中获取一个可复用的单元,当池子不为空,且当前尚未关闭的时候,可以拿到原来创建好的资源,否则利用工厂函数创建一个新的资源
- Release 释放资源并归还到池子当中,如果池子已经满了,或者已经关闭,则自动丢弃该对象即可。
- Close 关闭资源池,不再写入和读取资源,并释放资源(调用资源本身的Close方法)
// Acquire retrieves a resource from the pool.
func (p *Pool) Acquire() (io.Closer, error) {
select {
// Check for a free resource.
case r, wd := <-p.resources:
log.Println("Acquire:", "Shared Resource")
if !wd {
return nil, ErrPoolClosed
}
return r, nil
// Provide a new resource since there are none available.
default:
log.Println("Acquire:", "New Resource")
return p.factory()
}
}
// Release places a new resource onto the pool.
func (p *Pool) Release(r io.Closer) {
// Secure this operation with the Close operation.
p.mu.Lock()
defer p.mu.Unlock()
// If the pool is closed, discard the resource.
if p.closed {
r.Close()
return
}
select {
// Attempt to place the new resource on the queue.
case p.resources <- r:
log.Println("Release:", "In Queue")
// If the queue is already at cap we close the resource.
default:
log.Println("Release:", "Closing")
r.Close()
}
}
// Close will shutdown the pool and close all existing resources.
func (p *Pool) Close() error {
// Secure this operation with the Release operation.
p.mu.Lock()
defer p.mu.Unlock()
// If the pool is already close, don't do anything.
if p.closed {
return ErrPoolClosed
}
// Set the pool as closed.
p.closed = true
// Close the channel before we drain the channel of its
// resources. If we don't do this, we will have a deadlock.
close(p.resources)
// Close the resources
for r := range p.resources {
r.Close()
}
return nil
}