Golang连接池

package controllers

import (
    "io"
    "sync"
    "time"
    "errors"
    "fmt"
)

var (
    ErrInvalidConfig = errors.New("invalid pool config")//error().Error()//errors.New("invalid pool config")
    ErrPoolClosed    = errors.New("pool closed")
)

// 1、如果连接时数量已经满了，等待，等待一段时间后重新获取连接，尝试几次后返回连接失败错误，需要开启线程维护超时连接
// 2、资源释放，每次连接完后，释放连接，回归到连接池，连接池中空闲连接设置最大时间，空闲时间过长，断开连接，保留最新连接数
type PoolInterface interface {
    Acquire() (io.Closer, error) // 获取资源
    Release(io.Closer) error     // 释放资源
    Close(io.Closer) error       // 关闭资源
    Shutdown() error             // 关闭池
}

type factory func()(io.Closer, error)

type GenericPool struct {
    s sync.Mutex // 互斥锁
    Pool chan io.Closer  // 缓存channel
    maxOpen int   // 最大连接数
    minOpen int   // 最小连接数
    NumOpen int   // 当前连接数
    closed bool   // 池是否关闭
    maxIdle int  // 最大空闲数
    maxLifetime time.Duration // 最大生命周期
    factory factory  // 创建连接
}



func NewGenericPool(maxIdle,minOpen int, maxOpen int, maxLifetime time.Duration, factory factory)(*GenericPool, error) {
    if maxOpen <= 0 || minOpen > maxOpen {
        return nil, ErrInvalidConfig
    }
    p := &GenericPool{
        sync.Mutex{},
        make(chan io.Closer,maxOpen),
        maxOpen,
        minOpen,
        0,
        false,
        maxIdle,
        maxLifetime,
        factory,
    }
    for i:=0;i < minOpen;i++ {
        closer,err := factory()
        if err != nil {
            continue
        }
        p.NumOpen++
        p.Pool<-closer
        
    }
    p.closeIdleConn()
    return p,nil
}

// 尝试连接,3次连接失败返回错误
func (p *GenericPool)TryConnect()(io.Closer,error) {
    //NewGenericPool(0,0,0,0,factory)
    var closer io.Closer
    for i:=0;i<3;i++ {
        var err error
        closer,err = p.Acquire()
        if err != nil {
            if i >= 3 {
                fmt.Println("尝试连接失败")
                return nil,errors.New("连接失败")
            }
            time.Sleep(1)
        }
        return closer,nil
    }
    return closer,nil
}

// 获取连接
func (p *GenericPool)Acquire()(io.Closer,error) {
    if p.closed {
        return nil,ErrPoolClosed
    }

    for {

        closer,err := p.getOrCreate()
        if err != nil {
            // 没有获取到连接该如何处理，返回失败，然后等待几秒后重新Acquire，如果多次Acquire已经失败直接返回报错信息
            fmt.Println("超过最大数，创建失败")
            return nil,err
        }

        //todo maxlifetime处理

        return closer,nil
    }
}

func (p *GenericPool)getOrCreate()(io.Closer,error)  {
    // 监听channel相关的IO操作
    select{
    case closer:= <- p.Pool:// 如果通道中有数据直接返回，没有数据下次访问时，如果有资源释放依旧会获取到
        p.NumOpen ++
        return closer,nil
    default:
        //fmt.Println("获取池中失败")
    }

    p.s.Lock()

    // 如果池中当前数量大于等于最大资源，应该直接返回获取不到的，不明白为何还有返回，即使返回，为何是不先判断当前是否空闲状态
    if p.NumOpen >= p.maxOpen {

        //closer :=<-p.Pool
        p.s.Unlock()
        //fmt.Println("当前连接数大于最大连接数")
        return nil,errors.New("当前连接数大于最大连接数")

    }
    // 创建新连接
    closer,err := p.factory()
    if err != nil{
        p.s.Unlock()
        return nil,err
    }
    p.NumOpen ++
    p.s.Unlock()
    fmt.Println("创建新连接")
    return closer,nil
}

// 释放单个资源到连接池
func (p *GenericPool)Release(closer io.Closer)error  {
    if p.closed {
        return ErrPoolClosed
    }
    p.s.Lock()
    p.Pool <- closer
    p.s.Unlock()
    return nil
}

// 关闭池中长期不使用的连接
func (p *GenericPool)closeIdleConn()  {
    // 开启子线程监控空闲连接
    go func() {
        for {
            time.Sleep(time.Duration(p.maxLifetime)*time.Second)
            if len(p.Pool) > 1 && len(p.Pool) > p.minOpen {
                fmt.Println("3244:",len(p.Pool))
                    for i:=0;i<len(p.Pool)-p.minOpen;i++  {
                        closer := <- p.Pool
                        fmt.Println("清除超时空闲:",i,closer)
                        break
                    }

            }
        }
    }()
}

// 检测Pool里面空闲的close,取出其中部分数据关闭,关闭单个资源
func (p *GenericPool)Close(closer io.Closer)error  {
    p.s.Lock()
    p.Pool<-closer
    p.NumOpen --
    p.s.Unlock()
    return nil
}

// 关闭连接池 释放所有资源
func (p *GenericPool)ShutDown()error{
    //fmt.Println('2')
    if p.closed {
        return ErrPoolClosed
    }
    close(p.Pool)

    for closer := range p.Pool{
        fmt.Println("1")
            p.NumOpen --
            closer.Close()
            // _,ok := <-closer
    }

    p.closed = true
    //p.s.Unlock()
    return nil
}

func main() {

    GPool,err := controllers.NewGenericPool(10,2,10,5, func() (io.Closer, error){
        //a := io.Closer()
        return nil,nil
    })
    if err != nil {
        fmt.Println("创建失败")
    }
    fmt.Println("创建成功:",len(GPool.Pool))

    //for i:=0;i<3 ;i++  {
    closer,err :=GPool.TryConnect()
        GPool.TryConnect()
        GPool.TryConnect()
    GPool.TryConnect()
    GPool.TryConnect()
    GPool.TryConnect()
    closer,err = GPool.TryConnect()
    closer,err = GPool.TryConnect()
    closer,err = GPool.TryConnect()
    closer,err = GPool.TryConnect()
    //GPool.TryConnect()
    //GPool.TryConnect()
    //GPool.TryConnect()
    //GPool.TryConnect()
    //GPool.TryConnect()
    //}
    fmt.Println("当前空闲:",len(GPool.Pool),"累积创建:",GPool.NumOpen)
    time.Sleep(3)
    if err != nil {
        fmt.Println("获取失败")
    }
    //GPool.ShutDown()
    GPool.Close(closer)
    GPool.Close(closer)
    GPool.Close(closer)
    GPool.Close(closer)
    GPool.Close(closer)
    GPool.Close(closer)
    //GPool.Close(closer)
    fmt.Println("当前空闲1:",len(GPool.Pool),"当前在用1:",GPool.NumOpen)
    //GPool.TryConnect()
    fmt.Println("当前空闲2:",len(GPool.Pool),"当前在用2:",GPool.NumOpen)
    
    conn,err := GPool.TryConnect()
    if err != nil {
        if err != nil {
            fmt.Println("获取失败")
        }
    }
    fmt.Printf("%T",conn)
    time.Sleep(time.Duration(1000)*time.Second)
    return
}