源码 连接池 设计
问题：GRPC应用中是否必要建立连接池
实践：
import (
"LabGO/utils"
"fmt"
"runtime"
"sync"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/encoding/gzip"
)
var ConnPoolSize *int // 连接池最大可用连接数
var ConnPool []*grpc.ClientConn // 连接池
var ConnPoolThisInUse []bool // 连接当前使用状态
var ConnPoolLock sync.Mutex // 锁
// 在连接池中填入可用连接
func InitConnPool() {
ConnPoolSize = &conf.Config.GrpcConnPoolSize // 从环境配置中读取连接池大小
ConnPool = make([]*grpc.ClientConn, *ConnPoolSize)
ConnPoolThisInUse = make([]bool, *ConnPoolSize)
for i := 0; i < *ConnPoolSize; i++ {
c, err := NewConn()
if err != nil {
// TODO
defer func() {
log.SRELog.Error(err)
}()
continue
}
ConnPool[i] = c
}
}
// 检查指定连接是否可用
func chekcConnState(c *grpc.ClientConn) bool {
defer func() {
if e := recover(); e != nil {
var buf = make([]byte, 8192)
runtime.Stack(buf, true)
err := fmt.Errorf("recover: %v Stack:%v", e, string(buf))
log.SRELog.Error(err)
}
log.SRELog.Info("Leave chekcConnState")
}()
if c == nil {
return false
}
switch c.GetState().String() {
case "IDLE", "CONNECTING", "READY":
return true
case "TRANSIENT_FAILURE", "SHUTDOWN":
err := c.Close()
if err != nil {
log.SRELog.Error(err)
}
return false
default:
err := c.Close()
if err != nil {
log.SRELog.Error(err)
}
return false
}
}
// 维持连接池中的连接可用
func CheckConnPool() {
log.SRELog.Info("IN CheckConnPool", " ", len(ConnPool))
for i, c := range ConnPool {
if !chekcConnState(c) {
ConnPoolLock.Lock()
c1, err := NewConn()
if err != nil {
// TODO
defer func() {
log.SRELog.Error(err)
}()
ConnPoolLock.Unlock()
continue
}
ConnPool[i] = c1
ConnPoolLock.Unlock()
}
}
}
// 阻塞式获取可用连接
func GetAConnWithBlock() (*grpc.ClientConn, int) {
defer func() {
if e := recover(); e != nil {
var buf = make([]byte, 8192)
runtime.Stack(buf, true)
err := fmt.Errorf("recover: %v Stack:%v", e, string(buf))
log.SRELog.Error(err)
}
log.SRELog.Info("Leave GetAConnWithBlock")
}()
log.SRELog.Info("IN GetAConnWithBlock ", len(ConnPool))
for {
for i, c := range ConnPool {
if chekcConnState(c) && !ConnPoolThisInUse[i] {
ConnPoolLock.Lock()
ConnPoolThisInUse[i] = true
ConnPoolLock.Unlock()
return c, i
}
}
time.Sleep(time.Second)
}
}
// 获取可用连接，返回grpc客户端
func NewCli() (pb.CISClient, int) {
c, i := GetAConnWithBlock()
log.SRELog.Info("NewCli", c)
return NewClient(c), i
}
// 生成连接
func NewConn() (*grpc.ClientConn, error) {
// TODO
var opts = func() []grpc.DialOption {
return opts
}()
var target = utils.ConcatStr(conf.Config.SrvAddr, ":50053")
grpc.UseCompressor(gzip.Name)
return grpc.Dial(target, opts...)
}
// 生成客户端
func NewClient(conn *grpc.ClientConn) pb.CISClient {
return pb.NewCISClient(conn)
}
// 调用，获取可用客户端
gCli, idC := server.NewCli()
defer func() {
server.ConnPoolLock.Lock()
server.ConnPoolThisInUse[idC] = false
server.ConnPoolLock.Unlock()
}()
req, err := gCli.TestMethod(ctx, &pb.TestMethodReq{...})
从可用连接池中取出最后一个，设置过期时间、标记为使用状态、连接吃减少一个连接；
freeConn []*driverConn // free connections ordered by returnedAt oldest to newest 最旧的
如果其中没有
// Prefer a free connection, if possible.
last := len(db.freeConn) - 1
if strategy == cachedOrNewConn && last >= 0 {
// Reuse the lowest idle time connection so we can close
// connections which remain idle as soon as possible.
conn := db.freeConn[last]
db.freeConn = db.freeConn[:last]
conn.inUse = true
if conn.expired(lifetime) {
db.maxLifetimeClosed++
db.mu.Unlock()
conn.Close()
return nil, driver.ErrBadConn
}
db.mu.Unlock()
Go\src\database\sql\sql.go
// conn returns a newly-opened or cached *driverConn.
func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
db.mu.Lock()
if db.closed {
db.mu.Unlock()
return nil, errDBClosed
}
// Check if the context is expired.
select {
default:
case <-ctx.Done():
db.mu.Unlock()
return nil, ctx.Err()
}
lifetime := db.maxLifetime
// Prefer a free connection, if possible.
last := len(db.freeConn) - 1
if strategy == cachedOrNewConn && last >= 0 {
// Reuse the lowest idle time connection so we can close
// connections which remain idle as soon as possible.
conn := db.freeConn[last]
db.freeConn = db.freeConn[:last]
conn.inUse = true
if conn.expired(lifetime) {
db.maxLifetimeClosed++
db.mu.Unlock()
conn.Close()
return nil, driver.ErrBadConn
}
db.mu.Unlock()
// Reset the session if required.
if err := conn.resetSession(ctx); errors.Is(err, driver.ErrBadConn) {
conn.Close()
return nil, err
}
return conn, nil
}
// Out of free connections or we were asked not to use one. If we're not
// allowed to open any more connections, make a request and wait.
if db.maxOpen > 0 && db.numOpen >= db.maxOpen {
// Make the connRequest channel. It's buffered so that the
// connectionOpener doesn't block while waiting for the req to be read.
req := make(chan connRequest, 1)
reqKey := db.nextRequestKeyLocked()
db.connRequests[reqKey] = req
db.waitCount++
db.mu.Unlock()
waitStart := nowFunc()
// Timeout the connection request with the context.
select {
case <-ctx.Done():
// Remove the connection request and ensure no value has been sent
// on it after removing.
db.mu.Lock()
delete(db.connRequests, reqKey)
db.mu.Unlock()
atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))
select {
default:
case ret, ok := <-req:
if ok && ret.conn != nil {
db.putConn(ret.conn, ret.err, false)
}
}
return nil, ctx.Err()
case ret, ok := <-req:
atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))
if !ok {
return nil, errDBClosed
}
// Only check if the connection is expired if the strategy is cachedOrNewConns.
// If we require a new connection, just re-use the connection without looking
// at the expiry time. If it is expired, it will be checked when it is placed
// back into the connection pool.
// This prioritizes giving a valid connection to a client over the exact connection
// lifetime, which could expire exactly after this point anyway.
if strategy == cachedOrNewConn && ret.err == nil && ret.conn.expired(lifetime) {
db.mu.Lock()
db.maxLifetimeClosed++
db.mu.Unlock()
ret.conn.Close()
return nil, driver.ErrBadConn
}
if ret.conn == nil {
return nil, ret.err
}
// Reset the session if required.
if err := ret.conn.resetSession(ctx); errors.Is(err, driver.ErrBadConn) {
ret.conn.Close()
return nil, err
}
return ret.conn, ret.err
}
}
db.numOpen++ // optimistically
db.mu.Unlock()
ci, err := db.connector.Connect(ctx)
if err != nil {
db.mu.Lock()
db.numOpen-- // correct for earlier optimism
db.maybeOpenNewConnections()
db.mu.Unlock()
return nil, err
}
db.mu.Lock()
dc := &driverConn{
db: db,
createdAt: nowFunc(),
returnedAt: nowFunc(),
ci: ci,
inUse: true,
}
db.addDepLocked(dc, dc)
db.mu.Unlock()
return dc, nil
}
// driverConn wraps a driver.Conn with a mutex, to
// be held during all calls into the Conn. (including any calls onto
// interfaces returned via that Conn, such as calls on Tx, Stmt,
// Result, Rows)
type driverConn struct {
db *DB
createdAt time.Time
sync.Mutex // guards following
ci driver.Conn
needReset bool // The connection session should be reset before use if true.
closed bool
finalClosed bool // ci.Close has been called
openStmt map[*driverStmt]bool
// guarded by db.mu
inUse bool
returnedAt time.Time // Time the connection was created or returned.
onPut []func() // code (with db.mu held) run when conn is next returned
dbmuClosed bool // same as closed, but guarded by db.mu, for removeClosedStmtLocked
}
// putConn adds a connection to the db's free pool.
// err is optionally the last error that occurred on this connection.
func (db *DB) putConn(dc *driverConn, err error, resetSession bool) {
if !errors.Is(err, driver.ErrBadConn) {
if !dc.validateConnection(resetSession) {
err = driver.ErrBadConn
}
}
db.mu.Lock()
if !dc.inUse {
db.mu.Unlock()
if debugGetPut {
fmt.Printf("putConn(%v) DUPLICATE was: %s\n\nPREVIOUS was: %s", dc, stack(), db.lastPut[dc])
}
panic("sql: connection returned that was never out")
}
if !errors.Is(err, driver.ErrBadConn) && dc.expired(db.maxLifetime) {
db.maxLifetimeClosed++
err = driver.ErrBadConn
}
if debugGetPut {
db.lastPut[dc] = stack()
}
dc.inUse = false
dc.returnedAt = nowFunc()
for _, fn := range dc.onPut {
fn()
}
dc.onPut = nil
if errors.Is(err, driver.ErrBadConn) {
// Don't reuse bad connections.
// Since the conn is considered bad and is being discarded, treat it
// as closed. Don't decrement the open count here, finalClose will
// take care of that.
db.maybeOpenNewConnections()
db.mu.Unlock()
dc.Close()
return
}
if putConnHook != nil {
putConnHook(db, dc)
}
added := db.putConnDBLocked(dc, nil)
db.mu.Unlock()
if !added {
dc.Close()
return
}
}
// Satisfy a connRequest or put the driverConn in the idle pool and return true
// or return false.
// putConnDBLocked will satisfy a connRequest if there is one, or it will
// return the *driverConn to the freeConn list if err == nil and the idle
// connection limit will not be exceeded.
// If err != nil, the value of dc is ignored.
// If err == nil, then dc must not equal nil.
// If a connRequest was fulfilled or the *driverConn was placed in the
// freeConn list, then true is returned, otherwise false is returned.
func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
if db.closed {
return false
}
if db.maxOpen > 0 && db.numOpen > db.maxOpen {
return false
}
if c := len(db.connRequests); c > 0 {
var req chan connRequest
var reqKey uint64
for reqKey, req = range db.connRequests {
break
}
delete(db.connRequests, reqKey) // Remove from pending requests.
if err == nil {
dc.inUse = true
}
req <- connRequest{
conn: dc,
err: err,
}
return true
} else if err == nil && !db.closed {
if db.maxIdleConnsLocked() > len(db.freeConn) {
db.freeConn = append(db.freeConn, dc)
db.startCleanerLocked()
return true
}
db.maxIdleClosed++
}
return false
}
