Using Redis in PHP to implement intelligent switching of distributed locks

In a distributed system, since multiple nodes operate on the same resource at the same time, concurrency conflicts are prone to occur. To solve this problem, we usually use distributed locks to control access to shared resources. Redis is an efficient distributed cache that can be used to implement distributed locks. This article will introduce how to use Redis in PHP to implement distributed locks and realize intelligent switching.

1. What is a distributed lock?

Distributed lock means that when multiple nodes are accessing shared resources, only one node can operate the resource, and other nodes need to wait. Distributed locks contain two operations: acquiring locks and releasing locks. The operation of acquiring the lock needs to ensure thread safety and avoid repeated acquisition of the lock; the operation of releasing the lock needs to ensure that the lock is released correctly to prevent deadlock.

2. Use Redis to implement distributed locks

Redis is an in-memory database that can quickly access data and supports distribution. In Redis, you can use the set command to set the key and value. If the key does not exist, the setting can be successful; if the key already exists, the setting will fail. This feature can be used to implement distributed locks.

The specific implementation can be divided into two steps. The first step is to acquire the lock. Use the set command to set a key. If the setting is successful, it means that the lock has been acquired successfully. Otherwise, it means that the lock has been acquired by other nodes. The second step is to release the lock and use the del command to delete the key.

The following is a PHP sample code that uses Redis to implement distributed locks:

class RedisLock{
    protected $redis;
    protected $lockKey = 'distributed_lock';
    protected $timeout = 30; // 默认锁超时时间30s

    function __construct(){
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }

    function getRedisClient(){
        return $this->redis;
    }

    function setLock($key = ''){
        if(empty($key)){
            $key = $this->lockKey;
        }else{
            $key = $this->lockKey . '_' . $key; // 如果有传入锁键名，则拼接上前缀方便管理
        }

        $timeout = $this->timeout;

        while ($timeout > 0) { // 如果锁未超时，则等待获取锁
            $result = $this->redis->set($key, time() + $timeout, ['nx', 'ex' => $timeout]);

            if ($result){
                return true;
            }

            sleep(1); // 每次等待1秒钟
            $timeout = $timeout -1;
        }

        return false;
    }

    function unlock($key = ''){
        if(empty($key)){
            $key = $this->lockKey;
        }else{
            $key = $this->lockKey . '_' . $key; // 如果有传入锁键名，则拼接上前缀方便管理
        }

        return $this->redis->del($key);
    }
}

Use this class to easily obtain the lock:

$lock = new RedisLock();
if($lock->setLock()){
    // 执行需要获得锁的操作
    $lock->unlock();
}

3. Implement intelligent lock switching

The above distributed lock implementation is relatively simple, but when a node failure occurs, it will cause problems. For example, timing: Node A acquires the lock, but discovers a fault during operation, resulting in the lock being unable to be released normally. At this time, node B tries to acquire the lock, but fails because node A still holds the lock. In order to solve this problem, we can implement intelligent lock switching.

First, we need to implement a lock timeout reset mechanism, that is, after the lock times out, the lock is reset to an available state. This can be achieved through a scheduled task. Secondly, we need to record the lock holder. When an abnormal situation occurs, the holder's lock can be manually released. Finally, we need to implement a lock switching mechanism, that is, when the node holding the lock fails, other nodes can automatically switch to the lock holder.

For specific implementation, please refer to the following sample code:

class RedisLock {
    protected $redis;
    protected $lockKey = 'distributed_lock';
    protected $timeout = 30; // 默认锁超时时间30s

    // 锁的持有者
    protected $holder;

    // 获取锁的时间戳，用于超时释放锁
    protected $lockTime;

    function __construct(){
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }

    function getRedisClient(){
        return $this->redis;
    }

    function setLock($key = ''){
        if(empty($key)){
            $key = $this->lockKey;
        }else{
            $key = $this->lockKey . '_' . $key; // 如果有传入锁键名，则拼接上前缀方便管理
        }

        $timeout = $this->timeout;

        // 检查锁是否已被其他节点持有
        if($lockTime = $this->redis->get($key)){
            // 计算锁的剩余时间
            $remainTime = $lockTime + $timeout - time();

            // 如果锁剩余时间大于0，则表示其他节点持有锁
            if($remainTime > 0){
                return false;
            }
        }

        // 尝试获取锁
        $result = $this->redis->set($key, time() + $timeout, ['nx', 'ex' => $timeout]);

        if ($result){
            $this->holder = $key;
            $this->lockTime = time() + $timeout;

            return true;
        }

        return false;
    }

    function unlock($key = ''){
        if(empty($key)){
            $key = $this->lockKey;
        }else{
            $key = $this->lockKey . '_' . $key; // 如果有传入锁键名，则拼接上前缀方便管理
        }

        if($this->holder != $key){
            return false;
        }

        return $this->redis->del($key);
    }

    // 定时任务，每隔一段时间检查锁的持有者是否存活，如果不存活，则尝试切换为当前节点
    function timeoutReset(){
        while(true){
            if(time() > $this->lockTime){
                $this->redis->set($this->holder, '', ['nx', 'ex' => 1]);
            }

            $this->holder = $this->redis->get($this->lockKey);

            if(!$this->holder){
                $this->setLock();
            }

            sleep(1); // 每个一秒执行一次
        }
    }
}

The above implements intelligent lock switching. If node A fails, other nodes will automatically switch to the lock holder after the lock times out. This mechanism ensures the high availability and reliability of distributed locks.

4. Summary

This article introduces how to use Redis to implement distributed locks and implement an intelligent lock switching mechanism. This solution ensures the high availability and reliability of distributed locks and can be widely used in distributed systems. At the same time, this solution can also be used to solve other problems that require lock mechanisms, such as database read-write locks, distributed transactions, etc.

The above is the detailed content of Using Redis in PHP to implement intelligent switching of distributed locks. For more information, please follow other related articles on the PHP Chinese website!