Golang语言社区--golang通用连接池的实现

golang的channel除了goroutine通信之外还有很多其他的功能，本文将实现一种基于channel的通用连接池。

何为通用？

连接池的实现不依赖具体的实例，而依赖某个接口，本文的连接池选用的是io.Closer接口，只要是实现了该接口的对象都可以被池管理。
当然，你可以实现基于interface{}的连接池，这样任何对象都可以被管理。

实现原理

将连接句柄存入channel中，由于缓存channel的特性，获取连接时如果池中有连接，将直接返回，如果池中没有连接，将阻塞或者新建连接（没超过最大限制的情况下）。
由于面向接口编程，所有创建连接的逻辑是不清楚的，这里需要传入一个函数，该函数返回一个io.Closer对象。

实现

由于并发问题，在需要操作池中互斥数据的时候需要加锁。

1. package pool
   
2. 
   
3. import (
   
4.     "errors"
   
5.     "io"
   
6.     "sync"
   
7.     "time"
   
8. )
   
9. 
   
10. var (
    
11.     ErrInvalidConfig = errors.New("invalid pool config")
    
12.     ErrPoolClosed    = errors.New("pool closed")
    
13. )
    
14. 
    
15. type factory func() (io.Closer, error)
    
16. 
    
17. type Pool interface {
    
18.     Acquire() (io.Closer, error) // 获取资源
    
19.     Release(io.Closer) error     // 释放资源
    
20.     Close(io.Closer) error       // 关闭资源
    
21.     Shutdown() error             // 关闭池
    
22. }
    
23. 
    
24. type GenericPool struct {
    
25.     sync.Mutex
    
26.     pool        chan io.Closer
    
27.     maxOpen     int  // 池中最大资源数
    
28.     numOpen     int  // 当前池中资源数
    
29.     minOpen     int  // 池中最少资源数
    
30.     closed      bool // 池是否已关闭
    
31.     maxLifetime time.Duration
    
32.     factory     factory // 创建连接的方法
    
33. }
    
34. 
    
35. func NewGenericPool(minOpen, maxOpen int, maxLifetime time.Duration, factory factory) (*GenericPool, error) {
    
36.     if maxOpen <= 0 || minOpen > maxOpen {
    
37.         return nil, ErrInvalidConfig
    
38.     }
    
39.     p := &GenericPool{
    
40.         maxOpen:     maxOpen,
    
41.         minOpen:     minOpen,
    
42.         maxLifetime: maxLifetime,
    
43.         factory:     factory,
    
44.         pool:        make(chan io.Closer, maxOpen),
    
45.     }
    
46. 
    
47.     for i := 0; i < minOpen; i++ {
    
48.         closer, err := factory()
    
49.         if err != nil {
    
50.             continue
    
51.         }
    
52.         p.numOpen++
    
53.         p.pool <- closer
    
54.     }
    
55.     return p, nil
    
56. }
    
57. 
    
58. func (p *GenericPool) Acquire() (io.Closer, error) {
    
59.     if p.closed {
    
60.         return nil, ErrPoolClosed
    
61.     }
    
62.     for {
    
63.         closer, err := p.getOrCreate()
    
64.         if err != nil {
    
65.             return nil, err
    
66.         }
    
67.         // todo maxLifttime处理
    
68.         return closer, nil
    
69.     }
    
70. }
    
71. 
    
72. func (p *GenericPool) getOrCreate() (io.Closer, error) {
    
73.     select {
    
74.     case closer := <-p.pool:
    
75.         return closer, nil
    
76.     default:
    
77.     }
    
78.     p.Lock()
    
79.     if p.numOpen >= p.maxOpen {
    
80.         closer := <-p.pool
    
81.         p.Unlock()
    
82.         return closer, nil
    
83.     }
    
84.     // 新建连接
    
85.     closer, err := p.factory()
    
86.     if err != nil {
    
87.         p.Unlock()
    
88.         return nil, err
    
89.     }
    
90.     p.numOpen++
    
91.     p.Unlock()
    
92.     return closer, nil
    
93. }
    
94. 
    
95. // 释放单个资源到连接池
    
96. func (p *GenericPool) Release(closer io.Closer) error {
    
97.     if p.closed {
    
98.         return ErrPoolClosed
    
99.     }
    
100.     p.Lock()
     
101.     p.pool <- closer
     
102.     p.Unlock()
     
103.     return nil
     
104. }
     
105. 
     
106. // 关闭单个资源
     
107. func (p *GenericPool) Close(closer io.Closer) error {
     
108.     p.Lock()
     
109.     closer.Close()
     
110.     p.numOpen--
     
111.     p.Unlock()
     
112.     return nil
     
113. }
     
114. 
     
115. // 关闭连接池，释放所有资源
     
116. func (p *GenericPool) Shutdown() error {
     
117.     if p.closed {
     
118.         return ErrPoolClosed
     
119.     }
     
120.     p.Lock()
     
121.     close(p.pool)
     
122.     for closer := range p.pool {
     
123.         closer.Close()
     
124.         p.numOpen--
     
125.     }
     
126.     p.closed = true
     
127.     p.Unlock()
     
128.     return nil
     
129. }

复制代码

结论

基于该连接池，可以管理所有io.Closer对象。比如memcached,redis等等，非常方便！

Golang语言社区论坛网址：www.golang.ltd