go的连接资源释放问题、Mysql、Redis资源释放？

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《go的连接资源释放问题、Mysql、Redis资源释放？》，介绍一下MySQL、Redis、go，希望对大家的知识积累有所帮助，助力实战开发！

问题内容

背景：
新手学习Go做了一个API接口，然后用到了Mysql、Redis，这个资源释放问题有很大的疑惑

求各位高手指点，在线等，谢谢各位大佬，具体代码如下：

Redis

使用的这个包："github.com/go-redis/redis"
Redis 初始化文件：

import (
    "dot/pkg/logging"
    "dot/pkg/setting"
    "fmt"
    "github.com/go-redis/redis"
    "net"
    "time"
)

var RedisClient *redis.Client

// ServiceInit init Redis
func ServiceInit() {
    RedisClient = redis.NewClient(&redis.Options{
        // 连接信息
        DB:       0,                             // redis数据库index
        Network:  "tcp",                         // 网络类型，tcp or unix，默认tcp
        Addr:     setting.RedisSetting.Host,     // 主机名+冒号+端口，默认localhost:6379
        Password: setting.RedisSetting.Password, // 密码

        // 连接池容量及闲置连接数量
        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: setting.RedisSetting.IdleCheckFrequency * time.Second, // 闲置连接检查的周期，默认为1分钟，-1表示不做周期性检查，只在客户端获取连接时对闲置连接进行处理。
        IdleTimeout:        setting.RedisSetting.IdleTimeout * time.Minute,        // 闲置超时，默认5分钟，-1表示取消闲置超时检查
        MaxConnAge:         setting.RedisSetting.MaxConnAge * 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", setting.RedisSetting.Host)
        },

        //钩子函数
        OnConnect: func(conn *redis.Conn) error { //仅当客户端执行命令时需要从连接池获取连接时，如果连接池需要新建连接时则会调用此钩子函数
            return nil
        },
    })
    return
}

// Set 设置Key
func Set(key string, data interface{}, time time.Duration) error {
    RedisClient.Set(key,data,time)
    return nil
}

基本使用的时候都是这么使用，没有进行关闭

// 直接调用封装的方法
pkgname.Set(key , data, time)

Mysql

使用的Gorm
Mysql 初始化文件：

import (
    "dot/pkg/setting"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
    "gorm.io/gorm/schema"
    "log"
    "os"
    "strings"
    "time"
)

var Db *gorm.DB

// ServiceInit initializes the database instance
func ServiceInit() {
    var err error
    Logger := logger.New(
        log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
        logger.Config{
            Colorful:                  true,                   // 彩色打印
            LogLevel:                  logger.Info,            // 日志级别
            SlowThreshold:             200 * time.Millisecond, // 慢 SQL 阈值, 200ms
            IgnoreRecordNotFoundError: true,                   // 忽略ErrRecordNotFound（记录未找到）错误
        },
    )
    dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True&loc=Local&timeout=%s",
        setting.DatabaseSetting.User,
        setting.DatabaseSetting.Password,
        setting.DatabaseSetting.Host,
        setting.DatabaseSetting.Name,
        setting.DatabaseSetting.Timeout)

    Db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
        SkipDefaultTransaction:                   true,
        Logger:                                   Logger,
        DisableForeignKeyConstraintWhenMigrating: true,
        NamingStrategy: schema.NamingStrategy{
            SingularTable: true,                                   // 使用单数表名，启用该选项后，`Student` 表将是`student`, 禁用则为`students`
            TablePrefix:   setting.DatabaseSetting.TablePrefix,    // 表名前缀，`User`表为`pre_users`
            NameReplacer:  strings.NewReplacer("AbcID", "abc_id"), // 在转为数据库名称之前，使用NameReplacer更改结构/字段名称。
        },
    })

    if err != nil {
        panic("连接数据库失败, error=" + err.Error())
    }
}

调用的时候就直接使用了,也没有进行关闭：

// 写入数据库中，数据落地
func InsertBatchDB(login []PlayerLogin) (bool, error) {
    loginModSlice := []PlayerLogin{}
    for _, param := range login {
        loginMod := PlayerLogin{}
        _ = deepcopier.Copy(param).To(&loginMod)
        loginModSlice = append(loginModSlice, loginMod)
    }
    err := models.Db.Create(&loginModSlice).Error
    if err != nil {
        return false, err
    }
    return true, nil
}

到底啥时候关闭资源啊？应用不用关闭资源啊，求各位大佬辛苦解答一下，祝各位大佬顺风顺水、升职加薪

正确答案

这种写法是单例模式，init会在项目启动的时候就实例化，使用的时候复用不做关闭。
如果需要关闭连接那就需要有重新连接的方式

今天带大家了解了MySQL、Redis、go的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~