分布式锁

# 加锁
SETNX lock:order:{id} true
# 解锁
DEL lock:order:{id}

# 加锁并设置过期时间
SETNX lock:order:{id} true
EXPIRE lock:order:{id} 5

# 加锁并设置过期时间
SET lock:order:{id} true EX 5 NX

tag = random.nextint()  # 随机数
if redis.set(key, tag, nx=True, ex=5):
    do_something()
    redis.delifequals(key, tag)  # 假想的 delifequals 指令

# delifequals
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

package redistlock

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"errors"
	"fmt"
	"sync"
	"time"

	"github.com/go-redis/redis/v8"
)

const (
	defaultWatchdogInterval = 10 * time.Second // 默认续期间隔
	defaultLockTimeout     = 30 * time.Second // 默认锁超时时间
)

type DistLock struct {
	client         *redis.Client
	key            string
	value          string // 唯一标识，格式: UUID:goroutineID
	watchdogActive bool
	stopWatchdog   chan struct{}
	mutex          sync.Mutex
}

// NewDistLock 创建一个新的分布式锁实例
func NewDistLock(client *redis.Client, key string) *DistLock {
	return &DistLock{
		client:       client,
		key:          key,
		value:        generateLockValue(),
		stopWatchdog: make(chan struct{}),
	}
}

// generateLockValue 生成锁的唯一标识值
func generateLockValue() string {
	// 生成随机 UUID 部分
	buf := make([]byte, 16)
	_, _ = rand.Read(buf)
	uuid := hex.EncodeToString(buf)
	
	// 获取当前 goroutine ID
	goid := getGoroutineID()
	
	return fmt.Sprintf("%s:%d", uuid, goid)
}

// 获取 goroutine ID (简化实现)
func getGoroutineID() uint64 {
	var buf [64]byte
	n := runtime.Stack(buf[:], false)
	idField := strings.Fields(strings.TrimPrefix(string(buf[:n]), "goroutine "))[0]
	id, _ := strconv.ParseUint(idField, 10, 64)
	return id
}

// Lock 获取分布式锁
func (dl *DistLock) Lock(ctx context.Context, timeout time.Duration) error {
	dl.mutex.Lock()
	defer dl.mutex.Unlock()

	// 尝试获取锁
	acquired, err := dl.client.SetNX(ctx, dl.key, dl.value, defaultLockTimeout).Result()
	if err != nil {
		return err
	}

	if acquired {
		// 启动看门狗
		dl.startWatchdog(ctx)
		return nil
	}

	// 等待锁释放或超时
	if timeout > 0 {
		expire := time.Now().Add(timeout)
		ticker := time.NewTicker(100 * time.Millisecond)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				acquired, err := dl.client.SetNX(ctx, dl.key, dl.value, defaultLockTimeout).Result()
				if err != nil {
					return err
				}
				if acquired {
					dl.startWatchdog(ctx)
					return nil
				}
				if time.Now().After(expire) {
					return errors.New("lock timeout")
				}
			case <-ctx.Done():
				return ctx.Err()
			}
		}
	}

	return errors.New("lock acquisition failed")
}

// startWatchdog 启动看门狗续期机制
func (dl *DistLock) startWatchdog(ctx context.Context) {
	if dl.watchdogActive {
		return
	}

	dl.watchdogActive = true
	go func() {
		ticker := time.NewTicker(defaultWatchdogInterval)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				// 续期操作
				renewed, err := dl.renewLock(ctx)
				if err != nil || !renewed {
					// 续期失败，可能是锁已释放或已失去所有权
					dl.mutex.Lock()
					dl.watchdogActive = false
					dl.mutex.Unlock()
					return
				}
			case <-dl.stopWatchdog:
				// 收到停止信号
				dl.mutex.Lock()
				dl.watchdogActive = false
				dl.mutex.Unlock()
				return
			case <-ctx.Done():
				// 上下文取消
				dl.mutex.Lock()
				dl.watchdogActive = false
				dl.mutex.Unlock()
				return
			}
		}
	}()
}

// renewLock 续期锁
func (dl *DistLock) renewLock(ctx context.Context) (bool, error) {
	// 使用 Lua 脚本保证原子性
	script := `
	if redis.call("get", KEYS[1]) == ARGV[1] then
		return redis.call("pexpire", KEYS[1], ARGV[2])
	else
		return 0
	end
	`
	result, err := dl.client.Eval(ctx, script, []string{dl.key}, dl.value, defaultLockTimeout.Milliseconds()).Result()
	if err != nil {
		return false, err
	}

	if val, ok := result.(int64); ok {
		return val == 1, nil
	}
	return false, nil
}

// Unlock 释放锁
func (dl *DistLock) Unlock(ctx context.Context) error {
	dl.mutex.Lock()
	defer dl.mutex.Unlock()

	// 先停止看门狗
	if dl.watchdogActive {
		close(dl.stopWatchdog)
		dl.watchdogActive = false
		dl.stopWatchdog = make(chan struct{})
	}

	// 使用 Lua 脚本保证原子性
	script := `
	if redis.call("get", KEYS[1]) == ARGV[1] then
		return redis.call("del", KEYS[1])
	else
		return 0
	end
	`
	_, err := dl.client.Eval(ctx, script, []string{dl.key}, dl.value).Result()
	return err
}

// IsLocked 检查锁是否仍被当前实例持有
func (dl *DistLock) IsLocked(ctx context.Context) (bool, error) {
	val, err := dl.client.Get(ctx, dl.key).Result()
	if err == redis.Nil {
		return false, nil
	}
	if err != nil {
		return false, err
	}
	return val == dl.value, nil
}

127.0.0.1:6379> eval "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second
1) "key1"
2) "key2"
3) "first"
4) "second"

jedis.set("product_stock_10016", "15");  // 初始化商品10016的库存
String script = " local count = redis.call('get', KEYS[1]) " +
                " local a = tonumber(count) " +
                " local b = tonumber(ARGV[1]) " +
                " if a >= b then " +
                "   redis.call('set', KEYS[1], a-b) " +
                "   return 1 " +
                " end " +
                " return 0 ";
Object obj = jedis.eval(script, Arrays.asList("product_stock_10016"), Arrays.asList("10"));
System.out.println(obj);