分享使用redigo连到redis proxy踩到的坑

最近在开发项目的时候,踩了一个redis相关的坑,现分享给大家。

使用的第三方库是 redigo,

连的redis地址是一个proxy,

首先要说的是,redigo 和 redis proxy 都是好东西,redigo的源码看着很清晰,redis proxy也很棒。刀是好刀,但是用的姿势不对就会伤到自己。

这个坑就是关于redigo连接池的:

RedisPool = &redis.Pool{
		MaxIdle:     5,
		IdleTimeout: 240 * time.Second,
		Dial: func() (redis.Conn, error) {
			c, err := redis.Dial("tcp", address)
			if err != nil {
				println(err)
				return nil, err
			}
			_, err = c.Do("SELECT", db)
			if err != nil {
				println(err)
				return nil, err
			}
			return c, nil
		},
		TestOnBorrow: func(c redis.Conn, t time.Time) error {
			_, err := c.Do("PING")
			if err != nil {
				println(err)
			}
			return err

		},
	}

上图所示为老项目中的redigo redis pool,咋一看没啥问题,

MaxIdle: 池子里的最大空闲连接

IdleTimeout: 超过这个duration的空闲连接,会被关闭

TestOnBorrow: 用之前检查这个连接是不是健康的

问题就在于这个Dial,

Dial is an application supplied function for creating and configuring a connection.

pool结构体里的这个Dial 就是用来创建,并配置一个redis连接的。

坑就在这,我们执行redis 命令是通过connection对象的Do方法,

func (c *conn) Do(cmd string, args ...interface{}) (interface{}, error) {
	c.mu.Lock()
	pending := c.pending
	c.pending = 0
	c.mu.Unlock()

	if cmd == "" && pending == 0 {
		return nil, nil
	}

	if c.writeTimeout != 0 {
		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
	}

	if cmd != "" {
		if err := c.writeCommand(cmd, args); err != nil {
			return nil, c.fatal(err)
		}
	}

	if err := c.bw.Flush(); err != nil {
		return nil, c.fatal(err)
	}

	if c.readTimeout != 0 {
		c.conn.SetReadDeadline(time.Now().Add(c.readTimeout))
	}

	if cmd == "" {
		reply := make([]interface{}, pending)
		for i := range reply {
			r, e := c.readReply()
			if e != nil {
				return nil, c.fatal(e)
			}
			reply[i] = r
		}
		return reply, nil
	}

	var err error
	var reply interface{}
	for i := 0; i <= pending; i++ {
		var e error
		if reply, e = c.readReply(); e != nil {
			return nil, c.fatal(e)
		}
		if e, ok := reply.(Error); ok && err == nil {
			err = e
		}
	}
	return reply, err
}

如上述源码中,如果你不传入timeout的值,那么默认0值的话,这两个set deadline的逻辑就跳过了。。。

如果不设置read/write timeout 会导致什么问题呢?假如网络有波动,执行一个redis 命令的时候,一直没收到服务器的响应,会导致这次请求一直没有返回,晾在那。直到redis服务器设置的超时时间到了,关闭连接,然后就会读到一个EOF的错误。

  1. 单点redis的情况,如果不设置MaxActive,redis pool的连接数是没有上限的,问题就不会暴露出来,这对我们的服务来说,影响也不大,就是在错误日志中,会多几条redis相关的EOF日志,但是这样真的没问题么?当然有问题,如果是从redis读消息,没有设置read timeout,一直读不到,这个协程就卡在那,迟迟不给响应,对用户来说很不好。
  2. 使用集群模式,一般redis_proxy 会限制连接数,所以redis pool 就应该用MaxActive限制池子里的最大连接数,这时候如果不设置read/write timeout,问题就来了,池子里的连接会越来越少直到没有。

因此,不管那种情况,我们都应该给redis.Dial这个方法,传入三个超时时间,DialConnectTimeout, DialReadTimeout,DialWriteTimeout。

附上现在在用的 redigo的redis pool。

redis.Pool{
			MaxIdle: cf.StatsRedis.MaxIdle,
			MaxActive: cf.StatsRedis.MaxActive,
			Dial: func() (redis.Conn, error) {
				c, err := redis.Dial("tcp", cf.StatsRedis.ProxyAddress,
					redis.DialConnectTimeout(time.Duration(cf.StatsRedis.ConnectTimeout) * time.Millisecond),
					redis.DialReadTimeout(time.Duration(cf.StatsRedis.ReadTimeout) * time.Millisecond),
					redis.DialWriteTimeout(time.Duration(cf.StatsRedis.WriteTimeout) * time.Millisecond))
				if err != nil {
					l4g.Error(err)
					return nil, err
				}
				return c, nil
			},
			// Use the TestOnBorrow function to check the health of an idle connection
			// before the connection is returned to the application.
			TestOnBorrow: func(c redis.Conn, t time.Time) error {
				if time.Since(t) < time.Minute {
					return nil
				}
				_, err := c.Do("PING")
				return err
			},
			IdleTimeout: 300 * time.Second,
			// If Wait is true and the pool is at the MaxActive limit,
			// then Get() waits for a connection to be returned to the pool before returning
			Wait: true,
		},

之前一直以为redis.Dial这个方法会有默认的超时时间,结果事实证明它没有啊。。

写代码一定不能用“以为”。

其实也不能怪redigo,这个库底层用的是golang的net库,default timeout 就是0啊,which is interpreted as “no timeout”…

你可能感兴趣的:(Go实战系列)