分布式锁实现方案与选型建议-源码库

分布式锁实现方案与选型建议：从理论到实战的完整指南

在分布式系统开发中，我经常遇到需要协调多个服务对共享资源进行互斥访问的场景。经过多个项目的实践和踩坑，今天我想和大家系统地分享分布式锁的各种实现方案，以及在实际项目中如何做出合适的技术选型。

为什么需要分布式锁？

记得我第一次遇到分布式锁需求是在一个电商项目中，当时多个订单服务实例同时处理库存扣减，出现了超卖问题。传统单机环境的锁机制在分布式场景下完全失效，这才让我深刻认识到分布式锁的重要性。

基于Redis的分布式锁实现

Redis应该是目前最流行的分布式锁实现方案，我在大多数项目中都采用这种方式。

import redis
import time
import uuid

class RedisDistributedLock:
    def __init__(self, redis_client, lock_key, expire_time=30):
        self.redis_client = redis_client
        self.lock_key = lock_key
        self.expire_time = expire_time
        self.identifier = str(uuid.uuid4())
    
    def acquire(self, timeout=10):
        end_time = time.time() + timeout
        while time.time() < end_time:
            # 使用SET命令的NX和EX参数实现原子操作
            if self.redis_client.set(
                self.lock_key, 
                self.identifier, 
                ex=self.expire_time, 
                nx=True
            ):
                return True
            time.sleep(0.1)
        return False
    
    def release(self):
        # 使用Lua脚本保证原子性，只有锁的持有者才能释放
        lua_script = """
        if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
        else
            return 0
        end
        """
        self.redis_client.eval(lua_script, 1, self.lock_key, self.identifier)

踩坑提醒：一定要使用Lua脚本来保证释放锁的原子性，我曾经因为先判断再删除的非原子操作，导致锁被其他客户端误释放。

基于ZooKeeper的分布式锁

在金融类对一致性要求极高的项目中，我更倾向于使用ZooKeeper实现分布式锁。

public class ZkDistributedLock {
    private final CuratorFramework client;
    private final String lockPath;
    private InterProcessMutex lock;
    
    public ZkDistributedLock(String connectString, String lockPath) {
        this.client = CuratorFrameworkFactory.newClient(connectString, 
            new RetryNTimes(3, 1000));
        this.client.start();
        this.lockPath = lockPath;
        this.lock = new InterProcessMutex(client, lockPath);
    }
    
    public boolean tryLock(long timeout, TimeUnit unit) {
        try {
            return lock.acquire(timeout, unit);
        } catch (Exception e) {
            return false;
        }
    }
    
    public void unlock() {
        try {
            lock.release();
        } catch (Exception e) {
            // 处理异常
        }
    }
}

ZooKeeper通过临时顺序节点和Watch机制实现了真正的强一致性，但性能相比Redis要差一些。

基于数据库的分布式锁

在一些遗留系统或者不想引入额外中间件的场景下，数据库也可以作为分布式锁的实现方案。

-- 创建锁表
CREATE TABLE distributed_lock (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    lock_key VARCHAR(64) NOT NULL UNIQUE,
    holder_id VARCHAR(64) NOT NULL,
    expire_time DATETIME NOT NULL,
    created_time DATETIME DEFAULT CURRENT_TIMESTAMP
);

// 基于数据库乐观锁的实现
public boolean tryAcquireLock(String lockKey, String holderId, int expireSeconds) {
    String sql = "INSERT INTO distributed_lock (lock_key, holder_id, expire_time) " +
                 "VALUES (?, ?, DATE_ADD(NOW(), INTERVAL ? SECOND)) " +
                 "ON DUPLICATE KEY UPDATE " +
                 "holder_id = IF(expire_time < NOW(), VALUES(holder_id), holder_id), " +
                 "expire_time = IF(expire_time < NOW(), VALUES(expire_time), expire_time)";
    // 执行SQL并判断影响行数
}