code review 14642044: database/sql: Fix connection leaks and numOpen count

src/pkg/database/sql/sql.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package sql provides a generic interface around SQL (or SQL-like)
 // databases.
 //
 // The sql package must be used in conjunction with a database driver.
 // See http://golang.org/s/sqldrivers for a list of drivers.
 package sql
@@ skipping 486 matching lines @@
 
 // SetMaxIdleConns sets the maximum number of connections in the idle
 // connection pool.
 //
 // If MaxOpenConns is greater than 0 but less than the new MaxIdleConns
 // then the new MaxIdleConns will be reduced to match the MaxOpenConns limit
 //
 // If n <= 0, no idle connections are retained.
 func (db *DB) SetMaxIdleConns(n int) {
         db.mu.Lock()
-        defer db.mu.Unlock()
         if n > 0 {
                 db.maxIdle = n
         } else {
                 // No idle connections.
                 db.maxIdle = -1
         }
         // Make sure maxIdle doesn't exceed maxOpen
         if db.maxOpen > 0 && db.maxIdleConnsLocked() > db.maxOpen {
                 db.maxIdle = db.maxOpen
         }
+        var closing []*driverConn
         for db.freeConn.Len() > db.maxIdleConnsLocked() {
                 dc := db.freeConn.Back().Value.(*driverConn)
                 dc.listElem = nil
                 db.freeConn.Remove(db.freeConn.Back())
-                go dc.Close()
+                closing = append(closing, dc)
+        }
+        db.mu.Unlock()
+        for _, c := range closing {
+                c.Close()
         }
 }
 
 // SetMaxOpenConns sets the maximum number of open connections to the database.
 //
 // If MaxIdleConns is greater than 0 and the new MaxOpenConns is less than
 // MaxIdleConns, then MaxIdleConns will be reduced to match the new
 // MaxOpenConns limit
 //
 // If n <= 0, then there is no limit on the number of open connections.
@@ skipping 1119 matching lines @@
         var buf [2 << 10]byte
         return string(buf[:runtime.Stack(buf[:], false)])
 }
 
 // withLock runs while holding lk.
 func withLock(lk sync.Locker, fn func()) {
         lk.Lock()
         fn()
         lk.Unlock()
 }