Redis 锁机制（分布式锁）-JavaScript中文网-JavaScript教程资源分享门户

分布式锁的基本概念

分布式锁是一种用于协调多个进程或服务之间对共享资源进行访问控制的机制。在分布式系统中，多个节点可能会同时访问和修改共享资源，因此需要一种机制来确保同一时间只有一个节点能够操作这些资源。分布式锁通常通过一个中央协调者来管理锁的状态，以保证在任意时刻只有一个客户端持有锁。

使用 Redis 实现分布式锁的优势

Redis 是一种高性能的键值存储系统，广泛应用于缓存、消息队列、计数器等多种场景。使用 Redis 实现分布式锁具有以下优势：

性能优越：Redis 在内存中操作数据，响应速度快。
易于实现：基于 Redis 的 SETNX、EXPIRE 等命令可以方便地实现锁的功能。
灵活性高：可以通过不同的数据结构和命令组合来满足各种复杂的业务需求。

分布式锁的实现原理

1. SETNX 命令

SETNX（Set if Not Exists）是 Redis 中的一个原子操作，它表示只有在 key 不存在时才设置 key 的值。这是实现分布式锁的基础之一。

示例代码

SETNX lock_key "lock_value"

2. EXPIRE 命令

为了防止死锁，即当客户端获取锁后突然崩溃导致锁无法释放，需要为锁添加一个过期时间。EXPIRE 命令用于设置 key 的过期时间。

示例代码

EXPIRE lock_key 30

3. Lua 脚本

虽然 SETNX 和 EXPIRE 已经能够实现基本的锁功能，但在实际应用中还需要考虑并发情况下的安全问题。使用 Lua 脚本可以在 Redis 服务器端执行一系列操作，并且保证这些操作的原子性。

示例代码

local current = redis.call('get', KEYS[1])
if current == false then
    redis.call('set', KEYS[1], ARGV[1])
    redis.call('expire', KEYS[1], tonumber(ARGV[2]))
    return 1
end
return 0

这段 Lua 脚本首先检查 key 是否存在，如果不存在则设置 key 并设置过期时间，最后返回结果表明是否成功获取锁。

分布式锁的使用案例

场景一：任务调度

假设有一个任务调度系统，需要确保某个任务在同一时间内只能被执行一次。可以通过 Redis 分布式锁来实现这一需求。

实现步骤

客户端尝试获取锁。
如果获取到锁，则执行任务。
执行完毕后释放锁。

示例代码

// www.javascriptcn.com code example
import redis
import time

def acquire_lock(lock_name, acquire_timeout=10):
    identifier = str(uuid.uuid4())
    end = time.time() + acquire_timeout
    r = redis.Redis(host='localhost', port=6379, db=0)
    
    while time.time() < end:
        if r.setnx(lock_name, identifier):
            # 设置超时时间为30秒
            r.expire(lock_name, 30)
            return identifier
        
        elif not r.ttl(lock_name):
            r.expire(lock_name, 30)

        time.sleep(.001)

    return False

def release_lock(lock_name, identifier):
    r = redis.Redis(host='localhost', port=6379, db=0)
    pipe = r.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True

            pipe.unwatch()
            break

        except redis.exceptions.WatchError:
            pass

    return False

场景二：库存扣减

在电商系统中，商品的库存扣减是一个典型的需要分布式锁的场景，因为多用户同时购买同一件商品时，如果没有适当的锁机制，可能会导致库存超卖的问题。

实现步骤

获取商品库存的锁。
检查当前库存数量。
减少库存数量。
释放锁。

示例代码

// www.javascriptcn.com code example
import uuid
import time
from redis import Redis

redis_client = Redis(host='localhost', port=6379, db=0)

def lock_stock(stock_id):
    identifier = str(uuid.uuid4())
    end = time.time() + 5
    
    while time.time() < end:
        if redis_client.setnx("stock:" + stock_id, identifier):
            redis_client.expire("stock:" + stock_id, 5)
            return identifier
        else:
            time.sleep(0.01)
    
    return None

def unlock_stock(stock_id, identifier):
    pipe = redis_client.pipeline(True)
    while True:
        try:
            pipe.watch("stock:" + stock_id)
            if pipe.get("stock:" + stock_id) == identifier:
                pipe.multi()
                pipe.delete("stock:" + stock_id)
                pipe.execute()
                return True
            
            pipe.unwatch()
            break
        
        except redis.exceptions.WatchError:
            pass
    
    return False

def decrease_stock(stock_id, amount):
    identifier = lock_stock(stock_id)
    if identifier is None:
        raise Exception("无法获取锁")
    
    try:
        current_stock = int(redis_client.get("stock_count:" + stock_id))
        if current_stock < amount:
            raise Exception("库存不足")
        
        redis_client.decrby("stock_count:" + stock_id, amount)
    finally:
        unlock_stock(stock_id, identifier)

以上代码展示了如何通过 Redis 分布式锁来保证库存扣减操作的安全性和一致性。

分布式锁的注意事项

尽管 Redis 分布式锁提供了一种简单有效的解决方案，但在实际使用过程中仍需注意以下几点：

锁的粒度：锁的粒度过细会导致性能下降，而过粗则可能导致冲突增加。应根据实际情况选择合适的锁粒度。
锁的超时时间：过短的超时时间可能导致频繁的锁重试，过长的超时时间则可能导致死锁。应合理设置锁的超时时间。
锁的公平性：多个客户端争夺同一个锁时，应考虑锁的分配策略，以保证公平性。
异常处理：在实现锁的过程中需要充分考虑到可能出现的各种异常情况，并进行适当的错误处理。

小结

通过上述介绍，我们可以看到 Redis 分布式锁是一种强大且灵活的工具，适用于多种需要协调多个客户端访问共享资源的场景。正确理解和运用 Redis 分布式锁将极大地提升系统的可靠性和效率。