redis锁golang

发布时间:2024-11-22 00:11:19

使用Golang实现Redis锁

在分布式系统中，经常需要使用锁来保护临界资源的访问。Redis作为一款高性能的缓存数据库，在分布式锁的实现上也提供了很多方便的功能。本文将介绍如何使用Golang来实现基于Redis的锁。

1. 获取Redis连接

首先，我们需要获取到Redis的连接，可以使用Golang中的Redis客户端库来进行操作。常用的Redis客户端库有go-redis和redigo等。这里以go-redis为例，示例代码如下：

import "github.com/go-redis/redis"

func GetRedisClient() *redis.Client {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // password set
        DB:       0,  // use default DB
    })

    _, err := client.Ping().Result()
    if err != nil {
        panic(err)
    }

    return client
}

2. 加锁

在并发场景下，为了保证同一时刻只有一个协程能够获得锁，我们使用Redis的SETNX命令来实现。SETNX命令会在给定的键不存在时设置键的值为指定的字符串，如果键已经存在，则不进行任何操作。示例代码如下：

func Lock(key string, value string, expiration time.Duration) bool {
    result, err := client.SetNX(key, value, expiration).Result()
    if err != nil {
        panic(err)
    }

    return result
}

3. 解锁

解锁的过程主要是通过DEL命令来删除键。示例代码如下：

func Unlock(key string) bool {
    result, err := client.Del(key).Result()
    if err != nil {
        panic(err)
    }

    return result
}

4. 使用锁

使用锁的过程主要包括获取锁和释放锁两个步骤。示例代码如下：

func HandleResource() {
    if Lock("resource_lock", "lock_value", time.Second) {
        defer Unlock("resource_lock")

        // 业务逻辑
    } else {
        // 锁被占用，处理失败
    }
}

5. 锁的可重入性

在某些场景下，需要支持锁的可重入性，即同一个协程可以多次获取到同一把锁而不会发生死锁。基于Redis的锁可以通过thread-local storage来实现可重入性。示例代码如下：

type RedisLock struct {
    key     string
    value   string
    expires time.Duration
}

var localLocks map[int]*RedisLock

func Lock(key string, expires time.Duration) bool {
    goID := goroutineID()

    if localLocks[goID] != nil && localLocks[goID].key == key {
        return true
    }

    result, err := client.SetNX(key, value, expiration).Result()
    if err != nil {
        panic(err)
    }

    if result {
        localLocks[goID] = &RedisLock{key: key, value: value, expires: expires}
    }

    return result
}

func Unlock(key string) bool {
    goID := goroutineID()

    if localLocks[goID] != nil && localLocks[goID].key == key {
        result, err := client.Del(key).Result()
        if err != nil {
            panic(err)
        }

        delete(localLocks, goID)

        return result
    }

    return false
}

func goroutineID() int {
    var buf [2]byte
    n := runtime.Stack(buf[:], false)
    idField := strings.Fields(strings.TrimPrefix(string(buf[:n]), "goroutine "))[0]
    id, _ := strconv.Atoi(idField)
    return id
}

在上述代码中，使用localLocks map来存储每个协程获取到的锁，通过goroutineID函数获取当前协程的ID。

总结

本文介绍了如何使用Golang和Redis实现分布式锁。通过SETNX和DEL命令，我们可以实现基本的加锁和解锁功能。另外，通过使用thread-local storage，我们还可以支持锁的可重入性。在实际应用中，需要根据具体的业务场景和性能需求来选择合适的锁策略。