分布式锁教程

forever蔷薇

于 2024-07-09 17:08:59 发布

阅读量870

点赞数 25

文章标签：分布式 redis java spring

本文链接：https://blog.csdn.net/weixin_51429644/article/details/140299475

版权

分布式锁教程

一：锁的使用场景
二：JVM的本地锁
三：分布式锁的使用场景
四：SETNX实现与局限性
五：利用 Redis 的 SET 命令优化分布式锁
六：验证锁的值（Verify Value）
七：使用 Lua 脚本优化分布式锁
总结

一：锁的使用场景

1. 锁的基本概念

在并发编程中，锁是一种同步机制，用于控制多个线程或进程对共享资源的访问。正确使用锁可以防止数据冲突和不一致的问题，确保系统在多用户或多任务环境下的稳定性和正确性。

2. 锁的使用场景

锁主要用于以下几种场景：

互斥：当多个线程需要访问同一资源（如数据库、文件等）时，锁可以保证同一时间只有一个线程能访问该资源，其他线程必须等待，从而防止资源竞争和数据错乱。
顺序控制：在某些业务流程中，需要按照特定的顺序执行操作。通过锁可以控制执行的顺序，例如，确保某个操作完成后才进行下一个操作。
死锁的预防和解决：在复杂的系统中，多个锁可能相互依赖，导致系统陷入停滞，即死锁。合理设计锁的策略和顺序，可以预防或解决死锁问题。
条件同步：在某些情况下，线程需要在某个条件满足后才能继续执行，锁结合条件变量可以用来控制线程等待和唤醒的逻辑。

3. 示例：使用锁控制并发

假设有一个简单的计数器应用，多个线程需要增加计数器的值。如果不使用锁，多个线程同时修改同一变量可能会导致读写冲突和错误的结果。

示例代码（Java中的synchronized关键字实现互斥锁）:

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

在这个例子中，increment 方法被 synchronized 关键字修饰，确保了每次只有一个线程可以执行这个方法，保证了操作的原子性。

二：JVM的本地锁

1. JVM本地锁的概念

在Java中，JVM本地锁主要指的是内部锁或监视器锁，它们是Java中实现同步的基本方式。这种锁主要用于控制多线程对共享资源的访问，保障数据的一致性和完整性。

2. 使用场景

JVM本地锁通常用在以下场景：

单实例执行：确保在同一时刻，只有一个线程可以执行某个方法或代码块。
状态保护：在多线程环境中，保护对象状态不被并发修改导致的数据不一致。

3. synchronized关键字

在Java中，synchronized 是实现本地锁的一个关键机制。它可以用来修饰方法或者特定的代码块。

方法同步

当一个方法被声明为 synchronized，它的锁便是当前对象实例（对于实例方法）或者该类的Class对象（对于静态方法）。

public class SynchronizedExample {
    public synchronized void syncMethod() {
        // 只有获得了当前对象的锁的线程才能执行这个方法
    }
}

同步代码块

synchronized 也可以用来同步一个特定的代码块，而不是整个方法。

public class SynchronizedBlockExample {
    private final Object lock = new Object();

    public void performSyncTask() {
        synchronized (lock) {
            // 代码块，只有持有lock这个对象锁的线程才能进入这个代码块
        }
    }
}

4. JVM本地锁的特点

可重入：Java的内部锁是可重入的，即同一个线程可以多次获得同一把锁。
不支持超时：在Java的内部锁中，当线程A持续持有锁时，如果线程B也尝试去获取这个锁，线程B会无限期地阻塞下去，直到线程A释放锁。
无法中断：一旦线程开始等待获得内部锁，它不能被中断，直到它获得这个锁。

5. 不足与局限性

虽然JVM的本地锁在单个JVM进程中工作良好，但它不适用于多个JVM进程或分布式系统中，因为锁是不跨JVM的。在分布式系统中，我们需要使用分布式锁来处理跨多个进程或服务器的资源同步问题。

三：分布式锁的使用场景

1. 分布式锁的概念

分布式锁是一种在分布式系统中用来保持多个进程或服务间同步的机制。与JVM的本地锁不同，分布式锁能够跨不同的进程和机器工作，它是设计用来处理在不同系统或网络中运行的多个节点之间的数据一致性和同步问题。

2. 使用场景

分布式锁通常用于以下场景：

跨服务的资源同步：当多个服务或应用需要访问和修改同一资源时（如数据库记录或文件），分布式锁可以保证在任一时刻，只有一个服务能够进行操作。
分布式事务处理：在处理跨多个数据库或服务的事务时，分布式锁可以用来保证事务的一致性和完整性。
防止重复处理：在如电子商务系统中处理订单时，分布式锁可以防止同一订单被多次处理。
顺序控制：在需要全局顺序执行的任务中，如日志处理或任务调度，分布式锁可以用来保持全局执行顺序。

3. 实现技术

分布式锁的实现可以通过多种技术实现，包括但不限于：

数据库锁：利用数据库提供的锁机制来实现分布式锁。
基于缓存系统的锁：例如，使用Redis等缓存系统通过设置键的唯一性来实现锁的功能。
专门的分布式锁服务：如使用Zookeeper或Etcd这样的分布式协调服务来实现锁的功能。

四：SETNX实现与局限性

1. SETNX的基本实现

SETNX 是 Redis 提供的一个基础命令，用于实现锁的基本功能。它的全称是 “SET if Not eXists”，这意味着仅当键不存在时，才会设置键的值。

示例代码

import redis

client = redis.Redis(host='localhost', port=6379)

def acquire_lock(lock_name):
    # 尝试设置锁，只有在锁不存在时操作才会成功
    return client.setnx(lock_name, "locked")

在这个函数中，如果lock_name不存在，setnx将键设置为"locked"并返回True，表明锁已经成功获取。如果lock_name已存在，则返回False，表示锁当前被其他客户端持有。

2. SETNX的局限性

尽管SETNX简单且易于使用，但它有几个明显的局限性：

锁不会自动释放：如果客户端在获取锁后因为崩溃或其他原因未能释放锁，锁将永久存在，导致其他客户端无法获取锁。
无法设置锁持有时间：SETNX本身不支持设置锁的过期时间。如果没有额外的机制来处理锁的过期，长时间运行或出错的客户端可能导致资源被无限期锁定。

3. 解决方案引入

为了解决这些问题，可以在SETNX后立即使用EXPIRE命令为锁设置一个过期时间。这种方法虽然可以减轻问题，但两个命令非原子性的特点又引入了新的问题，例如在SETNX和EXPIRE之间客户端可能崩溃，导致锁没有设置过期时间。

在第五部分中，我们将详细讨论如何使用Redis的SET命令，结合NX和EX选项来原子性地设置键值和过期时间，从而优化分布式锁的实现。

五：利用 Redis 的 SET 命令优化分布式锁

1. 引入 SET 命令的原子性操作

在上一部分中，我们提到 SETNX 和 EXPIRE 的组合存在潜在的风险，因为两个命令的非原子性可能在命令之间的任何失败点导致锁没有正确设置过期时间。为了解决这个问题，Redis 提供了一种方法，可以通过单个 SET 命令同时设置键值和过期时间，确保操作的原子性。

2. 命令语法

从 Redis 2.6.12 版本开始，SET 命令可以与 NX（仅当键不存在时才设置）和 EX（设置键的过期时间，以秒为单位）选项一起使用，形成一个原子操作。

示例代码：

import redis

client = redis.Redis(host='localhost', port=6379)

def acquire_lock(lock_name, lock_timeout=10):
    # 使用 NX 选项确保只在没有锁时设置锁
    # 使用 EX 选项设置锁的自动过期，防止死锁
    result = client.set(lock_name, "locked", ex=lock_timeout, nx=True)
    return bool(result)

这段代码通过一个原子操作尝试获取锁，并设置过期时间。如果锁被成功设置，则返回 True，表明锁已被获取。如果 set 调用返回 None（当键已存在时），则表示锁当前正被其他客户端持有。

3. 优势与安全性

这种方法的主要优势是：

原子性：通过合并键的设置和过期时间的设置为单个命令，大幅降低了因命令间失败而引起的问题。
避免死锁：自动过期保证即使在持有锁的客户端失败后，锁也会被释放，防止了死锁的发生。
简洁性：代码更为简洁，易于理解和维护。

4. 应用场景

这种使用 SET 命令的锁适用于需要高可靠性和高性能的分布式系统中，尤其是在多个进程或服务必须互斥访问共享资源的场景中。

六：验证锁的值（Verify Value）

1. 验证锁的值的重要性

在分布式环境中，仅仅持有一个锁并不总能保证锁的安全性和唯一性，尤其是在复杂的环境中，可能会遇到锁过期后被另一个客户端获取，然后原客户端尝试释放锁的情况，这种情况被称为"锁误释放"。为了避免这种情况，可以在锁中存储一个唯一值（通常是随机生成的），并在执行解锁操作时验证这个值。

2. 实现方法

为了实现锁值验证，我们可以在获取锁时存储一个唯一的值（例如 UUID 或当前时间戳），然后在释放锁时检查这个值是否与存储的值匹配。

示例代码：

import redis
import uuid

client = redis.Redis(host='localhost', port=6379)

def acquire_lock(lock_name, lock_timeout=10):
    unique_value = str(uuid.uuid4())
    result = client.set(lock_name, unique_value, nx=True, ex=lock_timeout)
    if result:
        return unique_value  # 返回唯一值以供后续验证
    return None

def release_lock(lock_name, identifier):
    # 获取当前锁的值
    current_value = client.get(lock_name)
    
    if current_value and current_value.decode('utf-8') == identifier:
        # 如果锁的当前值与提供的标识符匹配，删除锁
        client.delete(lock_name)
        return True
    return False

3. 优点和应用场景

这种方法的主要优点是提高了锁的安全性，防止了锁被错误释放的风险。它特别适用于那些长时间持有锁或锁的持有时间可能超过预设过期时间的场景。

七：使用 Lua 脚本优化分布式锁

1. Lua 脚本的优势

在 Redis 中，Lua 脚本是一种强大的工具，可以用来执行原子性操作。使用 Lua 脚本可以确保多个操作在同一事务中执行，避免了由于网络延迟或其他问题导致的并发控制问题。对于分布式锁，Lua 脚本可以确保获取锁和设置过期时间的操作是原子的，并且在释放锁时进行验证。

2. Lua 脚本实现分布式锁

我们可以编写一个 Lua 脚本来实现锁的获取和释放。这个脚本将包括以下两个部分：

获取锁时，同时设置锁的值和过期时间。
释放锁时，验证锁的值，并且仅在验证通过时释放锁。

3. 示例代码

获取锁的 Lua 脚本

-- 尝试获取锁的 Lua 脚本
local lock_name = KEYS[1]
local unique_value = ARGV[1]
local expire_time = tonumber(ARGV[2])

if redis.call("SETNX", lock_name, unique_value) == 1 then
    redis.call("EXPIRE", lock_name, expire_time)
    return true
else
    return false
end

释放锁的 Lua 脚本

-- 释放锁的 Lua 脚本
local lock_name = KEYS[1]
local unique_value = ARGV[1]

if redis.call("GET", lock_name) == unique_value then
    redis.call("DEL", lock_name)
    return true
else
    return false
end

在 Python 中调用 Lua 脚本

我们可以使用 Redis-Py 库来执行上述 Lua 脚本。以下是示例代码：

import redis
import uuid

client = redis.Redis(host='localhost', port=6379)

acquire_lock_script = """
if redis.call("SETNX", KEYS[1], ARGV[1]) == 1 then
    redis.call("EXPIRE", KEYS[1], ARGV[2])
    return true
else
    return false
end
"""

release_lock_script = """
if redis.call("GET", KEYS[1]) == ARGV[1] then
    redis.call("DEL", KEYS[1])
    return true
else
    return false
end
"""

def acquire_lock(lock_name, lock_timeout=10):
    unique_value = str(uuid.uuid4())
    result = client.eval(acquire_lock_script, 1, lock_name, unique_value, lock_timeout)
    if result:
        return unique_value
    return None

def release_lock(lock_name, identifier):
    result = client.eval(release_lock_script, 1, lock_name, identifier)
    return result

# 获取锁
lock_id = acquire_lock('my_lock', 10)
if lock_id:
    try:
        # 执行需要同步的操作
        print("Lock acquired, executing critical section")
    finally:
        release_lock('my_lock', lock_id)

4. 优点和应用场景

使用 Lua 脚本来管理分布式锁具有以下优点：

原子性：所有操作在一个 Lua 脚本中完成，确保了操作的原子性。
减少网络往返：通过脚本将多个 Redis 命令合并为一个操作，减少了网络往返，提高了性能。
灵活性：可以在 Lua 脚本中实现复杂的逻辑，增强锁的功能。

总结

分布式锁在分布式系统中至关重要，它确保了多个进程或服务对共享资源的同步访问。本文介绍了从JVM本地锁到分布式锁的实现及其优化方法，包括使用Redis的SETNX命令、添加过期时间、使用Lua脚本来保证操作的原子性和安全性。通过这些方法，可以有效解决锁的获取和释放问题，防止死锁和误释放，提升系统的可靠性和性能。下一篇文章会详细介绍 Redisson 分布式锁的加锁、解锁原理。Redisson