go database/sql -- 连接的申请与释放 golang数据库mysql

database/sql是go自带的操作sql的库，它维护了sql的连接池，包括连接的申请和释放。
连接池 datebase/sql维护了连接池，其配置：

db.SetMaxIdleConns(10)//设置空闲连接池中的最大idle连接数 db.SetMaxOpenConns(100)//设置数据库连接最大打开数 db.SetConnMaxLifetime(time.Hour)//设置可重用连接的最长时间

【go database/sql -- 连接的申请与释放】操作MySQL的示例程序：

import ( "database/sql" _ "github.com/go-sql-driver/mysql" )func main() { db, _ := db.Open("mysql", "root:rootroot@/dqm?charset=utf8&parseTime=True&loc=Local") defer db.Close() db.SetMaxOpenConns(10) if err := db.Ping(); err != nil { fmt.Println("connect to MySQL failed, err:", err) return } rows, err := db.Query("select * from test where name = 'jackie' limit 10") if err != nil { fmt.Println("query error") } defer rows.Close() for rows.Next() { fmt.Println("close") } row, _ := db.Query("select * from test") fmt.Println(row, rows) }

db.Open(“mysql”, dsn)并不会真正连接MySQL，也不会校验数据库用户名/密码，仅校验了dsn格式。
只有在Ping()或者实际的Query()操作时才会建立连接。
故项目中一般在InitDB()时，除了Open()，还要Ping()以确认连接OK。
使用MySQL database/sql用于操作数据库的CRUD，当操作mysql时使用驱动：

import ( _ "github.com/go-sql-driver/mysql" )

它会自动注册mysql的驱动：

//github.com/go-sql-driver/mysql/driver.go func init() { sql.Register("mysql", &MySQLDriver{}) }

源码分析：初始化DB

// Open may just validate its arguments without creating a connection // to the database. To verify that the data source name is valid, call // Ping. func Open(driverName, dataSourceName string) (*DB, error) { driversMu.RLock() driveri, ok := drivers[driverName] driversMu.RUnlock() if !ok { return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName) } if driverCtx, ok := driveri.(driver.DriverContext); ok { connector, err := driverCtx.OpenConnector(dataSourceName) if err != nil { return nil, err } return OpenDB(connector), nil } return OpenDB(dsnConnector{dsn: dataSourceName, driver: driveri}), nil }

初始化DB仅构造了DB的结构，并没有创建真正的连接：

func OpenDB(c driver.Connector) *DB { ctx, cancel := context.WithCancel(context.Background()) db := &DB{ connector:c, openerCh:make(chan struct{}, connectionRequestQueueSize), resetterCh:make(chan *driverConn, 50), lastPut:make(map[*driverConn]string), connRequests: make(map[uint64]chan connRequest), stop:cancel, } go db.connectionOpener(ctx)//goroutine用于创建连接 go db.connectionResetter(ctx)//goroutine用于重置session return db }

获取连接
获取连接都是在具体的sql被执行的时候，如Query、Exec；

func (db *DB) Query(query string, args ...interface{}) (*Rows, error) { return db.QueryContext(context.Background(), query, args...) }func (db *DB) query(ctx context.Context, query string, args []interface{}, strategy connReuseStrategy) (*Rows, error) { dc, err := db.conn(ctx, strategy)//在这里获取连接：创建新的或使用cache的 if err != nil { return nil, err } //传入dc.releaseConn，query完毕后回调该函数 return db.queryDC(ctx, nil, dc, dc.releaseConn, query, args) }

通过db.conn()获取连接，先尝试从freeConn中拿，拿到就返回；否则看是否超过maxConn，没超就创建，否则进队列等待：

func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) { ...... // 尝试从连接池中拿 numFree := len(db.freeConn) if strategy == cachedOrNewConn && numFree > 0 { conn := db.freeConn[0] ... return conn, nil } // 如果超过最大连接数，要阻塞等待 if db.maxOpen > 0 && db.numOpen >= db.maxOpen { ...... } //创建一个新的连接 db.numOpen++ // optimistically ci, err := db.connector.Connect(ctx) dc := &driverConn{ db:db, createdAt: nowFunc(), ci:ci, inUse:true, } db.addDepLocked(dc, dc) return dc, nil }

释放连接
释放连接在query的db.releaseConn进行，释放连接实际是将连接放入连接池db.freeConn：

func (dc *driverConn) releaseConn(err error) { dc.db.putConn(dc, err, true) }// 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) { ...... added := db.putConnDBLocked(dc, nil) ...... }// Satisfy a connRequest or put the driverConn in the idle pool and return true // or return false. func (db *DB) putConnDBLocked(dc *driverConn, err error) bool { ...... db.freeConn = append(db.freeConn, dc) ...... }

查询时连接的释放 query的结果返回到Rows结构中，同时它把releaseConn传递给Row；

func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []interface{}) (*Rows, error) { ...... rows := &Rows{ dc:dc, releaseConn: releaseConn,//传递relaseConn函数 rowsi:rowsi, } rows.initContextClose(ctx, txctx) return rows, nil ...... }

而在Rows.Next()函数中：

func (rs *Rows) Next() bool { var doClose, ok bool withLock(rs.closemu.RLocker(), func() { doClose, ok = rs.nextLocked() }) if doClose {//发现没有记录了，就释放连接 rs.Close() } return ok }func (rs *Rows) Close() error { return rs.close(nil) }func (rs *Rows) close(err error) error { rs.closemu.Lock() defer rs.closemu.Unlock()if rs.closed { return nil } rs.closed = true//置关闭标志位 ...... rs.releaseConn(err)//释放连接 return err }

也就是说，用Rows.Next()来释放连接；但是，如果在使用时没有遍历到最后，它不会自动释放连接。
建议最好使用defer rows.Close()手动确认关闭，从代码可以看出，rows.Close()是可重入的(置closed标志位，下次调用直接return)。