func OpenDB

OpenDB

// OpenDB opens a database using a Connector, allowing drivers to
// bypass a string based data source name.
//
// Most users will open a database via a driver-specific connection
// helper function that returns a *DB. No database drivers are included
// in the Go standard library. See https://golang.org/s/sqldrivers for
// a list of third-party drivers.
//
// OpenDB may just validate its arguments without creating a connection
// to the database. To verify that the data source name is valid, call
// Ping.
//
// The returned DB is safe for concurrent use by multiple goroutines
// and maintains its own pool of idle connections. Thus, the OpenDB
// function should be called just once. It is rarely necessary to
// close a 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)
	go db.connectionResetter(ctx)

	return db
}

注释解释说：OpenDB可能仅仅验证连接参数而不会创建到DB的连接，要验证数据源是否有效，调用Ping函数。返回的DB会维护自己的空闲连接池，在整个项目运行过程中，OpenDB应该仅仅被调用一次。

在调用OpenDB时，函数内部启用了两个协程connectionOpener和connectionResetter。

connectionOpener

一个伴随整个进程运行的任务。当明确调用db.stop时，结束该协程。db.stop就是在上面代码创建DB时的cancel函数。openerCh在初始化时，被声明为一个初始长度的空结构体类型的channel结构。

// Runs in a separate goroutine, opens new connections when requested.
func (db *DB) connectionOpener(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case <-db.openerCh:
			db.openNewConnection(ctx)
		}
	}
}

下面是用于清除无效连接的方法，当调用putConnDBLocked函数时，发现当前缓存的空闲连接数小于配置的最大空闲连接时，触发该清理操作。也就是，每次向缓存池中放连接时，都会触发清理操作。

func (db *DB) connectionCleaner(d time.Duration) {
	const minInterval = time.Second

	if d < minInterval {
		d = minInterval
	}
	t := time.NewTimer(d)

	for {
		select {
		case <-t.C:
		case <-db.cleanerCh: // maxLifetime was changed or db was closed.
		}

		db.mu.Lock()
		d = db.maxLifetime
		if db.closed || db.numOpen == 0 || d <= 0 {
			db.cleanerCh = nil
			db.mu.Unlock()
			return
		}

		expiredSince := nowFunc().Add(-d)
		var closing []*driverConn
		for i := 0; i < len(db.freeConn); i++ {
			c := db.freeConn[i]
			if c.createdAt.Before(expiredSince) {
				closing = append(closing, c)
				last := len(db.freeConn) - 1
				db.freeConn[i] = db.freeConn[last]
				db.freeConn[last] = nil
				db.freeConn = db.freeConn[:last]
				i--
			}
		}
		db.maxLifetimeClosed += int64(len(closing))
		db.mu.Unlock()

		for _, c := range closing {
			c.Close()
		}

		if d < minInterval {
			d = minInterval
		}
		t.Reset(d)
	}
}

具体的实现重心就是如下的代码：这里比较特别的的是：i–的操作，每次前后的连接交换之后，下次还要再检查一遍。

for i := 0; i < len(db.freeConn); i++ {
	c := db.freeConn[i]
	if c.createdAt.Before(expiredSince) {
		closing = append(closing, c)
		last := len(db.freeConn) - 1
		db.freeConn[i] = db.freeConn[last]
		db.freeConn[last] = nil
		db.freeConn = db.freeConn[:last]
		i--
	}
}