PHP后端分布式锁的实现方案比较-源码库

PHP后端分布式锁的实现方案比较：从Redis到数据库的实战指南

作为一名在分布式系统领域摸爬滚打多年的开发者，我深知分布式锁在并发控制中的重要性。今天我想和大家分享几种在PHP后端实现分布式锁的方案，这些都是我在实际项目中亲身实践过的经验总结。

为什么需要分布式锁？

记得我第一次遇到分布式环境下的库存超卖问题时，才真正意识到分布式锁的必要性。在单机环境下，我们可以用文件锁或内存锁，但在分布式系统中，多个应用实例同时操作共享资源时，传统的锁机制就失效了。比如电商系统中的库存扣减、秒杀活动，都需要分布式锁来保证数据的一致性。

基于Redis的分布式锁实现

Redis是我最常用的分布式锁实现方案，因为它性能出色且实现相对简单。这里我分享一个基于Redis SETNX命令的实现方案：


class RedisDistributedLock
{
    private $redis;
    private $lockKey;
    private $lockValue;
    private $expireTime;
    
    public function __construct($redis, $lockKey, $expireTime = 10)
    {
        $this->redis = $redis;
        $this->lockKey = $lockKey;
        $this->expireTime = $expireTime;
        $this->lockValue = uniqid();
    }
    
    public function acquire()
    {
        $result = $this->redis->set(
            $this->lockKey, 
            $this->lockValue, 
            ['NX', 'EX' => $this->expireTime]
        );
        
        return $result !== false;
    }
    
    public function release()
    {
        $script = "
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end
        ";
        
        return $this->redis->eval($script, [$this->lockKey, $this->lockValue], 1);
    }
}

这里有几个关键点需要注意：使用唯一值作为锁的值，避免误删其他客户端的锁；设置合理的过期时间，防止死锁；使用Lua脚本保证原子性操作。我在实际项目中就遇到过因为没有设置唯一值，导致锁被误删的坑。

基于数据库的分布式锁实现

在没有Redis的环境下，数据库也是一个可行的选择。我通常使用MySQL的唯一索引来实现：


class DatabaseDistributedLock
{
    private $pdo;
    private $tableName = 'distributed_locks';
    
    public function __construct($pdo)
    {
        $this->pdo = $pdo;
    }
    
    public function acquire($lockName, $expireSeconds = 10)
    {
        try {
            $sql = "INSERT INTO {$this->tableName} (lock_key, lock_value, expire_time) 
                    VALUES (?, ?, ?)";
            $stmt = $this->pdo->prepare($sql);
            $expireTime = time() + $expireSeconds;
            return $stmt->execute([$lockName, uniqid(), $expireTime]);
        } catch (PDOException $e) {
            // 锁已存在，检查是否过期
            $this->cleanExpiredLocks($lockName);
            return false;
        }
    }
    
    public function release($lockName)
    {
        $sql = "DELETE FROM {$this->tableName} WHERE lock_key = ?";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([$lockName]);
    }
    
    private function cleanExpiredLocks($lockName)
    {
        $sql = "DELETE FROM {$this->tableName} WHERE lock_key = ? AND expire_time < ?";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([$lockName, time()]);
    }
}

数据库方案的优点是依赖少，但性能相对较差，在高并发场景下会对数据库造成较大压力。我曾经在一个项目中因为忘记清理过期锁，导致锁表数据膨胀，影响了系统性能。

基于ZooKeeper的分布式锁

对于对一致性要求极高的场景，ZooKeeper是个不错的选择。虽然配置相对复杂，但提供了更强的可靠性：


class ZookeeperDistributedLock
{
    private $zookeeper;
    private $lockPath = '/locks/';
    private $currentPath;
    
    public function __construct($connectionString)
    {
        $this->zookeeper = new Zookeeper($connectionString);
    }
    
    public function acquire($lockName, $timeout = 10000)
    {
        $path = $this->lockPath . $lockName;
        $this->currentPath = $this->zookeeper->create(
            $path . '/lock-', 
            '', 
            [Zookeeper::EPHEMERAL | Zookeeper::SEQUENCE]
        );
        
        $children = $this->zookeeper->getChildren($path);
        sort($children);
        
        $currentNode = basename($this->currentPath);
        $currentIndex = array_search($currentNode, $children);
        
        if ($currentIndex === 0) {
            return true; // 获得锁
        }
        
        // 监听前一个节点
        $previousNode = $path . '/' . $children[$currentIndex - 1];
        if ($this->zookeeper->exists($previousNode)) {
            // 等待前一个节点释放
            $this->zookeeper->get($previousNode, [$this, 'watchNode']);
            return false;
        }
        
        return true;
    }
}

ZooKeeper通过临时顺序节点和Watch机制实现了公平锁，但学习成本较高，我在初次使用时花了很长时间才理解其原理。