Biegral Blog

      原文发表于：

 

      池子，是一个很广义的概念，电池，酒池，水池，资源池，进程池，线程池，协程池，内存池，连接池，都是池子。今天，我们以MySql数据库为例，来说说连接池。如下是MySql的执行流程图：

       

       我们知道，TCP的连接需要经历三次握手，TCP的关闭需要经历四次挥手，都需要耗费时间，而MySql的认证和关闭也同样需要耗费时间。自然地，我们想到了MySql连接的复用：把建立好的连接保留起来，用完后不关闭，放在池子中，从而形成连接池，下次需要用的时候，直接去连接池中拿连接。

 

       我们在本地建立一个数据库，并以golang包中的连接池为例，来验证一下连接池。在通常情况下，我们不要依赖于默认的参数，建议显式设置参数，比如：

DB.SetMaxOpenConns(5)  // 最大连接数
DB.SetMaxIdleConns(3)  // 最大空闲连接数(连接池容量)

        我们看代码：

package main

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

var DB *sql.DB
var dataBase = "root:pw123456@tcp(127.0.0.1:3306)/"

func init() {
        var err error
        DB, err = sql.Open("mysql", dataBase)
        if err != nil {
                fmt.Println("open db error:", err)
                panic("open db error xxx")
        }

        DB.SetMaxOpenConns(5)
        DB.SetMaxIdleConns(3)

        err = DB.Ping()
        if err != nil {
                fmt.Println("ping db error:", err)
                panic("ping db error xxx")
        }
}

func worker(i int) {
        var connection_id int
        err := DB.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
        if err != nil {
                fmt.Println("query connection id error:", err)
                return
        }

        fmt.Println("worker:", i, ", connection id:", connection_id)
}

func main() {

        for i:=0; i < 10; i++ {
                go worker(i)
        }
        
        for {}
}

        运行一下：

taoge:~/go/src/pool$ go run taoge.go 
worker: 0 , connection id: 67
worker: 9 , connection id: 67
worker: 1 , connection id: 67
worker: 7 , connection id: 67
worker: 8 , connection id: 67
worker: 2 , connection id: 68
worker: 6 , connection id: 69
worker: 5 , connection id: 67
worker: 4 , connection id: 71
worker: 3 , connection id: 70

taoge:~$ netstat -na | grep 3306 | grep ESTABLISHED | grep "0  127.0.0.1.3306" 
tcp4       0      0  127.0.0.1.3306         127.0.0.1.62730        ESTABLISHED
tcp4       0      0  127.0.0.1.3306         127.0.0.1.62728        ESTABLISHED
tcp4       0      0  127.0.0.1.3306         127.0.0.1.62726        ESTABLISHED
taoge:~$ 

 

       可以看到，使用的连接数为5，稳定的长连接数为3.

 

       我们可以想象一下，如果加入sleep, 会怎样呢？看代码：

package main

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

var DB *sql.DB
var dataBase = "root:pw123456@tcp(127.0.0.1:3306)/"

func init() {
        var err error
        DB, err = sql.Open("mysql", dataBase)
        if err != nil {
                fmt.Println("open db error:", err)
                panic("open db error xxx")
        }

        DB.SetMaxOpenConns(5)
        DB.SetMaxIdleConns(3)

        err = DB.Ping()
        if err != nil {
                fmt.Println("ping db error:", err)
                panic("ping db error xxx")
        }
}

func worker(i int) {
        var connection_id int
        err := DB.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
        if err != nil {
                fmt.Println("query connection id error:", err)
                return
        }

        fmt.Println("worker:", i, ", connection id:", connection_id)
}

func main() {

        for i:=0; i < 10; i++ {
                go worker(i)
                time.Sleep(time.Second)
        }
        
        for {}
}

        运行一下：

taoge:~/go/src/pool$ go run taoge.go 
worker: 0 , connection id: 72
worker: 1 , connection id: 72
worker: 2 , connection id: 72
worker: 3 , connection id: 72
worker: 4 , connection id: 72
worker: 5 , connection id: 72
worker: 6 , connection id: 72
worker: 7 , connection id: 72
worker: 8 , connection id: 72
worker: 9 , connection id: 72

taoge:~$ netstat -na | grep 3306 | grep ESTABLISHED | grep "0  127.0.0.1.3306" 
tcp4       0      0  127.0.0.1.3306         127.0.0.1.62835        ESTABLISHED
taoge:~$ 

 

       可以看到，前面一个协程查完MySql后，后面一个协程才开始来查询，这种情况下，就只需要1个连接就行了，后续协程直接从连接池中获取这个连接，进行复用，提升了效率。

 

       那么，连接池是怎样实现的呢？一图胜千言：

 

      连接池很重要，经常能在实际项目中提升服务性能。如下是一次实际项目中的耗时优化效果(数据已经脱敏)：

 

      OK, 先说到这里。