golang使用redis（二）

麦穗儿 · · 657 次点击 · · 开始浏览

这是一个创建于的文章，其中的信息可能已经有所发展或是发生改变。

redis连接池
使用连接池的目的就是复用之前建立的连接，不用每次都重建TCP连接，提高吞吐率。
有几个参数说明一下
MaxIdle： pool中最大Idle连接数量
MaxActive： pool中最大分配的连接数量，设为0无限制
IdleTimeout： idle的时间，超过idle时间连接关闭。设为0 idle的连接不close
Wait： 设为true，当请求时如果达到MaxActive会等待有连接被close。设为false，当请求时如果达到MaxActive会返回error

package main

import (
    "fmt"
    "os"
    "sync"
    "time"

    redis "github.com/gomodule/redigo/redis"
)

const (
    MAXIDLE       = 50
    MAXACTIVE     = 5000
    IDLETIMEOUT   = 30 * time.Second
    ROUNTINECOUNT = 50
)

func deferClose(con *redis.Conn) {
    fmt.Println("close")
    (*con).Close()
}

func main() {

    redisPool := &redis.Pool{
        MaxIdle:     MAXIDLE,
        MaxActive:   MAXACTIVE,
        IdleTimeout: IDLETIMEOUT,
        Wait:        true,
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp",
                "172.17.84.205:6379",
                redis.DialKeepAlive(20*time.Second),
                redis.DialPassword("123456"),
                redis.DialConnectTimeout(15*time.Second),
                redis.DialReadTimeout(15*time.Second),
                redis.DialWriteTimeout(15*time.Second))

            if err != nil {
                fmt.Println(err)
            }
            return c, err
        },
    }

    var wg sync.WaitGroup
    wg.Add(2 * ROUNTINECOUNT)

    for i := 0; i < ROUNTINECOUNT; i++ {
        go func(routineNum int) {
            for cnt := 0; cnt < 1000; cnt++ {
                c := redisPool.Get()
                //defer c.Close()

                key := fmt.Sprintf("key_%d_%d", routineNum, cnt)
                value := fmt.Sprintf("value_%d_%d", routineNum, cnt)

                _, err := c.Do("set", key, value)
                if err != nil {
                    fmt.Printf("set %s:%v\n", key, err)
                }
                fmt.Printf("s %s\n", value)

                if cnt%50 == 0 {
                    aCount := redisPool.Stats().ActiveCount
                    wCount := redisPool.Stats().WaitCount
                    fmt.Printf("activeCount:%d, waitCount:%d\n", aCount, wCount)
                }

                c.Close()
                //time.Sleep(50 * time.Millisecond)
            }

            wg.Done()
        }(i)

        go func(routineNum int) {
            for cnt := 0; cnt < 1000; cnt++ {
                c := redisPool.Get()
                //defer c.Close()
                key := fmt.Sprintf("key_%d_%d", routineNum, cnt)
                value, err := redis.String(c.Do("get", key))
                if err != nil {
                    fmt.Printf("get %s:%v\n", key, err)
                }

                fmt.Printf("g %s\n", value)
                c.Close()
            }
            wg.Done()
        }(i)

    }
    wg.Wait()

}

func errCheck(err error) {
    if err != nil {
        fmt.Println(err)
        os.Exit(-1)
    }
}

在测试时发现