分布式锁面试题详解与解析，Redis分布式锁面试题

欧气 2025年03月25日 04:39 1 0

本文目录导读：

图片来源于网络，如有侵权联系删除

什么是分布式锁？
分布式锁的实现方式
实际应用中的注意事项

在当今的云计算和微服务架构中，分布式锁是确保数据一致性和并发控制的关键技术之一，本文将深入探讨分布式锁的概念、实现方式以及在实际应用中的注意事项。

什么是分布式锁？

定义与必要性

分布式锁是指在分布式系统中用于同步多个节点访问共享资源的机制，由于多台服务器可能同时尝试修改同一资源，因此需要一种机制来防止竞态条件的发生,从而保证系统的稳定性和数据的完整性。

应用场景

数据库事务: 在高并发环境下，多个请求可能会同时写入同一个表,导致数据不一致。
文件系统操作: 多个进程或线程可能试图在同一时间读写文件,造成混乱。
缓存更新: 当多个服务都依赖相同的缓存时,更新缓存的数据可能导致数据不一致。

分布式锁的实现方式

基于Redis的分布式锁

Redis是一种常用的键值存储系统,它提供了原子性的SETNX命令来实现简单的分布式锁：

import redis
def acquire_lock(redis_client, lock_name):
    """ 尝试获取锁 """
    if redis_client.setnx(lock_name, 'locked'):
        return True
    else:
        return False
def release_lock(redis_client, lock_name):
    """ 释放锁 """
    # 使用Lua脚本避免竞态条件
    script = """
    if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
    else
        return 0
    end
    """
    redis_client.eval(script, 1, lock_name, 'locked')
# 示例使用
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
lock_name = "my_distributed_lock"
if acquire_lock(redis_client, lock_name):
    try:
        # 执行需要加锁的操作
        pass
    finally:
        release_lock(redis_client, lock_name)

基于ZooKeeper的分布式锁

ZooKeeper提供了一个watcher机制,可以用来构建复杂的分布式锁结构：

分布式锁面试题详解与解析，Redis分布式锁面试题

图片来源于网络，如有侵权联系删除

import org.apache.zookeeper.*;
import java.util.concurrent.CountDownLatch;
public class DistributedLock {
    private ZooKeeper zookeeper;
    private String lockPath;
    private String currentNodePath;
    public DistributedLock(ZooKeeper zookeeper, String lockPath) {
        this.zookeeper = zookeeper;
        this.lockPath = lockPath;
    }
    public void acquire() throws KeeperException, InterruptedException {
        String ephemeralNodeName = UUID.randomUUID().toString();
        currentNodePath = zookeeper.create(lockPath + "/node-", ephemeralNodeName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                                           CreateMode.EPHEMERAL_SEQUENTIAL);
        CountDownLatch latch = new CountDownLatch(1);
        watchChildNode(zookeeper, currentNodePath, latch);
        while (!latch.await(1000, TimeUnit.MILLISECONDS)) {
            byte[] data = zookeeper.getData(lockPath, false, null);
            int myIndex = Integer.parseInt(currentNodePath.substring(currentNodePath.lastIndexOf('/') + 1));
            int nextIndex = Integer.parseInt(new String(data).substring(1)); // 获取下一个节点的索引
            if (nextIndex > myIndex) {
                latch.countDown(); // 如果当前节点不是最小节点，则继续等待
            }
        }
    }
    private void watchChildNode(ZooKeeper zk, String path, CountDownLatch latch) throws KeeperException, InterruptedException {
        List<String> children = zk.getChildren(path, true);
        Collections.sort(children); // 对子节点进行排序
        for (String child : children) {
            if (Integer.parseInt(child) < Integer.parseInt(path.substring(path.lastIndexOf('/') + 1))) {
                zk.exists(path + "/" + child, true); // 监听子节点变化
            } else {
                break; // 当前节点是最小的节点
            }
        }
        latch.countDown(); // 所有更小编号的节点都已监听完毕
    }
    public void release() throws KeeperException, InterruptedException {
        zookeeper.delete(currentNodePath, -1);
    }
}