为什么会有连接池这个东西

redis是基于内存的，计算的效率很高，但是网络通信是redis性能提升的瓶颈，如果redis服务器每次都要与客户端随机创立连接然后释放连接，会造成一定性能浪费，执行的效率会大大降低。
连接池的技术就是redis服务端预先开通连接，等客户端需要的时候，直接从连接池里面取出连接，然后使用。不再是当客户端需要的时候再去创建连接了，提高了资源的利用率和访问速度。

说明：通过 Golang对Redis操作, 还可以通过Redis链接池 流程如下：

  • 事先初始化一定数量的链接，放入到链接池
  • 当 Go需要操作Redis时，直接从Redis链接池取出链接即可。
  • 这样可以节省临时获取 Redis 链接的时间，从而提高效率。

image.png

pool.go 源码

  1. type Pool struct {
  2.     // Dial is an application supplied function for creating and configuring a
  3.     // connection.
  4.     //
  5.     // The connection returned from Dial must not be in a special state
  6.     // (subscribed to pubsub channel, transaction started, ...).
  7.     Dial func() (Conn, error)
  9.     // DialContext is an application supplied function for creating and configuring a
  10.     // connection with the given context.
  11.     //
  12.     // The connection returned from Dial must not be in a special state
  13.     // (subscribed to pubsub channel, transaction started, ...).
  14.     DialContext func(ctx context.Context) (Conn, error)
  16.     // TestOnBorrow is an optional application supplied function for checking
  17.     // the health of an idle connection before the connection is used again by
  18.     // the application. Argument t is the time that the connection was returned
  19.     // to the pool. If the function returns an error, then the connection is
  20.     // closed.
  21.     TestOnBorrow func(c Conn, t time.Time) error
  23.     // Maximum number of idle connections in the pool.
  24.     MaxIdle int
  26.     // Maximum number of connections allocated by the pool at a given time.
  27.     // When zero, there is no limit on the number of connections in the pool.
  28.     MaxActive int
  30.     // Close connections after remaining idle for this duration. If the value
  31.     // is zero, then idle connections are not closed. Applications should set
  32.     // the timeout to a value less than the server's timeout.
  33.     IdleTimeout time.Duration
  35.     // If Wait is true and the pool is at the MaxActive limit, then Get() waits
  36.     // for a connection to be returned to the pool before returning.
  37.     Wait bool
  39.     // Close connections older than this duration. If the value is zero, then
  40.     // the pool does not close connections based on age.
  41.     MaxConnLifetime time.Duration
  43.     mu           sync.Mutex    // mu protects the following fields
  44.     closed       bool          // set to true when the pool is closed.
  45.     active       int           // the number of open connections in the pool
  46.     initOnce     sync.Once     // the init ch once func
  47.     ch           chan struct{} // limits open connections when p.Wait is true
  48.     idle         idleList      // idle connections
  49.     waitCount    int64         // total number of connections waited for.
  50.     waitDuration time.Duration // total time waited for new connections.
  51. }

核心代码:

  1. var pool *redis.Pool
  3. // 初始化连接池
  4. pool = &redis.Pool{
  5.     MaxIdle:     8,   //最大空闲链接数
  6.     MaxActive:   0,   //表示和数据库的最大链接数，0表示没有限制
  7.     IdleTimeout: 100, //最大空闲时间
  8.     Dial: func() (redis.Conn, error) { // 初始化链接的代码，链接哪个ip的redis
  9.         return redis.Dial("tcp", "localhost:6379")
  10.     },
  11. }
  13. c := pool.Get() // 从连接池中取出一个链接
  14. pool.Close()    // 关闭连接池,一旦关闭链接池，就不能从链接池连接

代码体验

  1. // redis 连接池
  2. package main
  4. import (
  5.     "fmt"
  7.     "github.com/gomodule/redigo/redis"
  8. )
  10. // 定义一个全局的 pool
  11. var pool *redis.Pool
  13. // 当启动程序时，初始化连接池
  14. func init() {
  15.     pool = &redis.Pool{
  16.         MaxIdle:     8,   //最大空闲链接数
  17.         MaxActive:   0,   //表示和数据库的最大链接数，0表示没有限制
  18.         IdleTimeout: 100, //最大空闲时间
  19.         Dial: func() (redis.Conn, error) { // 初始化链接的代码，链接哪个ip的redis
  20.             return redis.Dial("tcp", "localhost:6379")
  21.         },
  22.     }
  23. }
  25. func main() {
  26.     fmt.Printf("pool 类型： %T, 值： %v \n", pool, pool)
  27.     // 1. 先从 pool 里面取出连接
  28.     conn := pool.Get()
  29.     // conn 类型： *redis.activeConn, 值： &{0xc000070500 0xc0000aa000 0}
  30.     fmt.Printf("conn 类型： %T, 值： %v \n", conn, conn)
  31.     defer conn.Close()
  33.     // 2. 操作
  34.     _, err := conn.Do("Set", "watch", "xiaomi")
  35.     if err != nil {
  36.         fmt.Println("操作失败", err)
  37.         return
  38.     }
  39.     val, err := redis.String(conn.Do("Get", "watch"))
  40.     if err != nil {
  41.         fmt.Println("操作失败", err)
  42.         return
  43.     }
  44.     fmt.Println("val =", val)
  46.     // 关闭连接池, 不能再继续读写了
  47.     pool.Close()
  48.     conn2 := pool.Get()
  49.     fmt.Println("conn2=", conn2)
  51.     _, err = conn2.Do("Set", "watch2", "xiaomi222")
  52.     if err != nil {
  53.         // Set()操作失败 redigo: get on closed pool
  54.         fmt.Println("Set()操作失败", err)
  55.         return
  56.     }
  57.     val, err = redis.String(conn2.Do("Get", "watch2"))
  58.     if err != nil {
  59.         fmt.Println("get操作失败", err)
  60.         return
  61.     }
  62.     fmt.Println("val2 =", val)
  63. }