官网文档：https://redis.uptrace.dev/guide/#ecosystem
github： https://github.com/go-redis/redis
goredislib “github.com/go-redis/redis/v8”
redis连接池 go-redis
参考URL: https://www.cnblogs.com/CJ-cooper/p/15149273.html
go-redis 源码分析：连接池
参考URL: http://t.zoukankan.com/ExMan-p-12396854.html
go-redis模块自带连接池，所有参数都是可选的，参数配置说明:
Options参数详解
type Options struct {
// 网络类型 tcp 或者 unix.
// 默认是 tcp.
Network string
// redis地址，格式 host:port
Addr string
// 新建一个redis连接的时候，会回调这个函数
OnConnect func(*Conn) error
// redis密码，redis server没有设置可以为空。
Password string
// redis数据库，序号从0开始，默认是0，可以不用设置
DB int
// redis操作失败最大重试次数，默认不重试。
MaxRetries int
// 最小重试时间间隔.
// 默认是 8ms ; -1 表示关闭.
MinRetryBackoff time.Duration
// 最大重试时间间隔
// 默认是 512ms; -1 表示关闭.
MaxRetryBackoff time.Duration
// redis连接超时时间.
// 默认是 5 秒.
DialTimeout time.Duration
// socket读取超时时间
// 默认 3 秒.
ReadTimeout time.Duration
// socket写超时时间
WriteTimeout time.Duration
// redis连接池的最大连接数.
// 默认连接池大小等于 cpu个数 * 10
PoolSize int
// redis连接池最小空闲连接数.
MinIdleConns int
// redis连接最大的存活时间，默认不会关闭过时的连接.
MaxConnAge time.Duration
// 当你从redis连接池获取一个连接之后，连接池最多等待这个拿出去的连接多长时间。
// 默认是等待 ReadTimeout + 1 秒.
PoolTimeout time.Duration
// redis连接池多久会关闭一个空闲连接.
// 默认是 5 分钟. -1 则表示关闭这个配置项
IdleTimeout time.Duration
// 多长时间检测一下，空闲连接
// 默认是 1 分钟. -1 表示关闭空闲连接检测
IdleCheckFrequency time.Duration
// 只读设置，如果设置为true， redis只能查询缓存不能更新。
readOnly bool
}
MaxIdle: 最大空闲连接数；
没有redis操作时依然可以保持这个连接数量，但要在IdleTimeout的时间范围内，不然就会关闭，结合IdleTimeout进行理解；
IdleTimeout: 5 * 60 * time.Second，
表示空闲连接保活时间，超过该时间后，连接会自动关闭，其实在默认情况下，当程序空闲时，redis连接池中是没有连接的；详情参见github。
MaxActive:最大连接数，一般为0，代表不限制；
同一时间最多有这么多的连接，包括连接池中的连接以及连接池外的连接，假设最大空闲MaxIdle设置3，MaxActive设置4，那么，当连接池的连接全部处于忙碌状态时，如果这时候程序过来取连接，发现连接池没有取到，这时候就还可以再额外创建一个连接，当该连接关闭时，如果连接池中空闲数量小于3，则该连接会被放到连接池中，如果空闲数等于3，则该连接会直接关闭；
go-redis包自带了连接池，会自动维护redis连接，因此创建一次client即可，不要查询一次redis就关闭client。
网上代码demo：
package main
import (
"fmt"
"github.com/go-redis/redis"
"net/http"
"net"
"time"
)
var gClient *redis.Client
func handler(w http.ResponseWriter, r *http.Request) {
gClient.Ping().Result()
printRedisPool(gClient.PoolStats())
fmt.Fprintf(w, "Hello")
}
func printRedisPool(stats *redis.PoolStats) {
fmt.Printf("Hits=%d Misses=%d Timeouts=%d TotalConns=%d IdleConns=%d StaleConns=%d\n",
stats.Hits, stats.Misses, stats.Timeouts, stats.TotalConns, stats.IdleConns, stats.StaleConns)
}
func printRedisOption(opt *redis.Options) {
fmt.Printf("Network=%v\n", opt.Network)
fmt.Printf("Addr=%v\n", opt.Addr)
fmt.Printf("Password=%v\n", opt.Password)
fmt.Printf("DB=%v\n", opt.DB)
fmt.Printf("MaxRetries=%v\n", opt.MaxRetries)
fmt.Printf("MinRetryBackoff=%v\n", opt.MinRetryBackoff)
fmt.Printf("MaxRetryBackoff=%v\n", opt.MaxRetryBackoff)
fmt.Printf("DialTimeout=%v\n", opt.DialTimeout)
fmt.Printf("ReadTimeout=%v\n", opt.ReadTimeout)
fmt.Printf("WriteTimeout=%v\n", opt.WriteTimeout)
fmt.Printf("PoolSize=%v\n", opt.PoolSize)
fmt.Printf("MinIdleConns=%v\n", opt.MinIdleConns)
fmt.Printf("MaxConnAge=%v\n", opt.MaxConnAge)
fmt.Printf("PoolTimeout=%v\n", opt.PoolTimeout)
fmt.Printf("IdleTimeout=%v\n", opt.IdleTimeout)
fmt.Printf("IdleCheckFrequency=%v\n", opt.IdleCheckFrequency)
fmt.Printf("TLSConfig=%v\n", opt.TLSConfig)
}
func main() {
gClient = redis.NewClient(&redis.Options{
//连接信息
Network: "tcp", //网络类型，tcp or unix，默认tcp
Addr: "127.0.0.1:6379", //主机名+冒号+端口，默认localhost:6379
Password: "", //密码
DB: 0, // redis数据库index
//连接池容量及闲置连接数量
PoolSize: 15, // 连接池最大socket连接数，默认为4倍CPU数， 4 * runtime.NumCPU
MinIdleConns: 10, //在启动阶段创建指定数量的Idle连接，并长期维持idle状态的连接数不少于指定数量；。
//超时
DialTimeout: 5 * time.Second, //连接建立超时时间，默认5秒。
ReadTimeout: 3 * time.Second, //读超时，默认3秒， -1表示取消读超时
WriteTimeout: 3 * time.Second, //写超时，默认等于读超时
PoolTimeout: 4 * time.Second, //当所有连接都处在繁忙状态时，客户端等待可用连接的最大等待时长，默认为读超时+1秒。
//闲置连接检查包括IdleTimeout，MaxConnAge
IdleCheckFrequency: 60 * time.Second, //闲置连接检查的周期，默认为1分钟，-1表示不做周期性检查，只在客户端获取连接时对闲置连接进行处理。
IdleTimeout: 5 * time.Minute, //闲置超时，默认5分钟，-1表示取消闲置超时检查
MaxConnAge: 0 * time.Second, //连接存活时长，从创建开始计时，超过指定时长则关闭连接，默认为0，即不关闭存活时长较长的连接
//命令执行失败时的重试策略
MaxRetries: 0, // 命令执行失败时，最多重试多少次，默认为0即不重试
MinRetryBackoff: 8 * time.Millisecond, //每次计算重试间隔时间的下限，默认8毫秒，-1表示取消间隔
MaxRetryBackoff: 512 * time.Millisecond, //每次计算重试间隔时间的上限，默认512毫秒，-1表示取消间隔
//可自定义连接函数
Dialer: func() (net.Conn, error) {
netDialer := &net.Dialer{
Timeout: 5 * time.Second,
KeepAlive: 5 * time.Minute,
}
return netDialer.Dial("tcp", "127.0.0.1:6379")
},
//钩子函数
OnConnect: func(conn *redis.Conn) error { //仅当客户端执行命令时需要从连接池获取连接时，如果连接池需要新建连接时则会调用此钩子函数
fmt.Printf("conn=%v\n", conn)
return nil
},
})
defer gClient.Close()
printRedisOption(gClient.Options())
printRedisPool(gClient.PoolStats())
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
官网：https://redis.uptrace.dev/
package main
import (
"context"
"github.com/go-redis/redis/v8"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password set
DB: 0, // use default DB
})
err := rdb.Set(ctx, "key", "value", 0).Err()
if err != nil {
panic(err)
}
val, err := rdb.Get(ctx, "key").Result()
if err != nil {
panic(err)
}
fmt.Println("key", val)
val2, err := rdb.Get(ctx, "key2").Result()
if err == redis.Nil {
fmt.Println("key2 does not exist")
} else if err != nil {
panic(err)
} else {
fmt.Println("key2", val2)
}
// Output: key value
// key2 does not exist
}
Distributed locks with Redis：Redis 官方出品，用 Redis 实现分布式互斥锁。Go 的实现 github.com/go-redsync/redsync
redsync是redis官方推荐的go版本分布式锁实现,标准的官方redlock算法实现。
rs := redsync.New(goredis.NewPool(client))
mutex:= rs.NewMutex("xxx", redsync.WithExpiry(10*time.Minute)),
使用思路：
client := goredislib.NewClient(&goredislib.Options{
Addr: fmt.Sprintf(“%s:%d”, cfg.RedisOptions.Host, cfg.RedisOptions.Port),
Username: cfg.RedisOptions.Username,
Password: cfg.RedisOptions.Password,
})
rs := redsync.New(goredis.NewPool(client))
mutex:= rs.NewMutex("my-mutex", redsync.WithExpiry(10*time.Minute))
if err := s.mutex.Lock(); err != nil {
log.Info("there is already an xxx instance running.")
return
}
defer func() {
if _, err := s.mutex.Unlock(); err != nil {
log.Errorf("could not release xxx lock. err: %v", err)
}
}()
github:https://github.com/go-redsync/redsync
package main
import (
goredislib "github.com/go-redis/redis/v8"
"github.com/go-redsync/redsync/v4"
"github.com/go-redsync/redsync/v4/redis/goredis/v8"
)
func main() {
// Create a pool with go-redis (or redigo) which is the pool redisync will
// use while communicating with Redis. This can also be any pool that
// implements the `redis.Pool` interface.
client := goredislib.NewClient(&goredislib.Options{
Addr: "localhost:6379",
})
pool := goredis.NewPool(client) // or, pool := redigo.NewPool(...)
// Create an instance of redisync to be used to obtain a mutual exclusion
// lock.
rs := redsync.New(pool)
// Obtain a new mutex by using the same name for all instances wanting the
// same lock.
mutexname := "my-global-mutex"
mutex := rs.NewMutex(mutexname)
// Obtain a lock for our given mutex. After this is successful, no one else
// can obtain the same lock (the same mutex name) until we unlock it.
if err := mutex.Lock(); err != nil {
panic(err)
}
// Do your work that requires the lock.
// Release the lock so other processes or threads can obtain a lock.
if ok, err := mutex.Unlock(); !ok || err != nil {
panic("unlock failed")
}
}
代码解释：
//用go-redis（或redigo）创建一个池，redisync将在与Redis通信时使用。也可以是任何实现redis.pool接口的池。
client := goredislib.NewClient(&goredislib.Options{
Addr: "localhost:6379",
})
pool := goredis.NewPool(client) // or, pool := redigo.NewPool(...)
// Create an instance of redisync to be used to obtain a mutual exclusion
// lock.
rs := redsync.New(pool)
//创建一个用于获得相互排除的redisync的实例锁
mutexname := "my-global-mutex"
mutex := rs.NewMutex(mutexname)
为我们给定的mutex获得一个锁。成功之后，没有其他人可以获取相同的锁（相同的mutex名称），直到我们解锁为止。
if err := mutex.Lock(); err != nil {
panic(err)
}