跳到主要内容

Redis 分布式锁模式

在现代分布式系统中，多个进程或线程可能需要同时访问共享资源。为了避免竞争条件（Race Condition），我们需要一种机制来确保同一时间只有一个进程可以访问这些资源。Redis分布式锁模式正是为了解决这一问题而设计的。

什么是分布式锁？​

分布式锁是一种用于在分布式系统中协调多个进程或线程对共享资源访问的机制。它的核心思想是通过一个共享的存储系统（如Redis）来实现锁的获取和释放，从而确保同一时间只有一个进程可以持有锁。

为什么需要分布式锁？​

在单机环境中，我们可以使用线程锁（如互斥锁）来保护共享资源。但在分布式环境中，多个服务可能运行在不同的机器上，无法直接使用线程锁。这时，分布式锁就派上了用场。

Redis 分布式锁的基本实现​

Redis分布式锁的核心思想是利用Redis的原子操作（如SETNX）来实现锁的获取和释放。以下是一个简单的实现步骤：

  1. 获取锁：使用SETNX命令尝试在Redis中设置一个键值对。如果键不存在，则设置成功，表示获取锁；如果键已存在，则设置失败，表示锁已被其他进程持有。
  2. 释放锁：使用DEL命令删除键，释放锁。

代码示例​

以下是一个使用Redis实现分布式锁的简单示例：

python
import redis
import time

# 连接到Redis
r = redis.Redis(host='localhost', port=6379, db=0)

def acquire_lock(lock_name, acquire_timeout=10):
    """尝试获取锁"""
    end_time = time.time() + acquire_timeout
    while time.time() < end_time:
        if r.setnx(lock_name, 'locked'):
            return True
        time.sleep(0.1)
    return False

def release_lock(lock_name):
    """释放锁"""
    r.delete(lock_name)

# 使用示例
lock_name = 'my_lock'
if acquire_lock(lock_name):
    try:
        # 执行需要保护的代码
        print("Lock acquired, doing some work...")
        time.sleep(5)
    finally:
        release_lock(lock_name)
        print("Lock released")
else:
    print("Failed to acquire lock")

输入与输出​

  • 输入：尝试获取名为my_lock的锁。
  • 输出：
    • 如果成功获取锁，输出Lock acquired, doing some work...，并在5秒后释放锁，输出Lock released。
    • 如果获取锁失败，输出Failed to acquire lock。

分布式锁的进阶实现​

上述简单实现存在一些问题，例如锁可能被错误地释放（如持有锁的进程崩溃）。为了解决这些问题，我们可以引入以下改进：

  1. 设置锁的过期时间：使用SET命令的EX选项为锁设置一个过期时间，防止锁被永久持有。
  2. 使用唯一标识符：为每个锁设置一个唯一标识符（如UUID），确保只有持有锁的进程才能释放锁。

改进后的代码示例​

python
import redis
import time
import uuid

# 连接到Redis
r = redis.Redis(host='localhost', port=6379, db=0)

def acquire_lock(lock_name, acquire_timeout=10, lock_timeout=10):
    """尝试获取锁，并设置过期时间"""
    identifier = str(uuid.uuid4())
    end_time = time.time() + acquire_timeout
    while time.time() < end_time:
        if r.set(lock_name, identifier, ex=lock_timeout, nx=True):
            return identifier
        time.sleep(0.1)
    return False

def release_lock(lock_name, identifier):
    """释放锁，确保只有持有锁的进程才能释放"""
    with r.pipeline() as pipe:
        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

# 使用示例
lock_name = 'my_lock'
identifier = acquire_lock(lock_name)
if identifier:
    try:
        # 执行需要保护的代码
        print("Lock acquired, doing some work...")
        time.sleep(5)
    finally:
        release_lock(lock_name, identifier)
        print("Lock released")
else:
    print("Failed to acquire lock")

输入与输出​

  • 输入：尝试获取名为my_lock的锁，并设置过期时间。
  • 输出：
    • 如果成功获取锁，输出Lock acquired, doing some work...，并在5秒后释放锁，输出Lock released。
    • 如果获取锁失败，输出Failed to acquire lock。

实际应用场景​

场景1：分布式任务调度​

在分布式任务调度系统中，多个任务调度器可能同时尝试执行同一个任务。为了避免重复执行，可以使用Redis分布式锁来确保只有一个调度器可以执行任务。

场景2：库存扣减​

在电商系统中，多个用户可能同时尝试购买同一件商品。为了避免超卖，可以使用Redis分布式锁来确保库存扣减操作的原子性。

总结​

Redis分布式锁模式是分布式系统中协调多个进程或线程访问共享资源的重要机制。通过使用Redis的原子操作，我们可以实现简单而高效的分布式锁。然而，实际应用中还需要考虑锁的过期时间、唯一标识符等问题，以确保锁的正确性和可靠性。

附加资源与练习​

  • 资源：
  • 练习：
    • 尝试在分布式环境中实现一个简单的任务调度系统，使用Redis分布式锁来确保任务的唯一执行。
    • 修改上述代码，使其支持可重入锁（即同一个进程可以多次获取同一个锁）。
提示

在实际生产环境中，建议使用成熟的分布式锁库（如Redlock）来避免手动实现分布式锁时可能遇到的复杂问题。