Using Redis to implement distributed locks in PHP

With the rapid development of the Internet and the sharp increase in website visits, the importance of distributed systems has gradually become prominent. In distributed systems, issues of concurrency synchronization and data consistency are inevitably involved. Distributed locks, as a means of solving concurrency synchronization problems, have gradually been widely used in distributed systems. In PHP, Redis can be used to implement distributed locks, which this article will introduce.

What is a distributed lock?

In a distributed system, when multiple machines process the same task together, in order to avoid multiple machines operating on the same resource at the same time, the resource needs to be locked. Distributed lock is a mechanism for locking shared resources in a distributed system. Distributed locks need to ensure the following two requirements:

1. Mutual exclusivity: Only one client can hold the lock at any time.

2. Reentrancy: The same client can acquire the lock multiple times.

There are many ways to implement distributed locks, such as using databases, using zookeeper, etc. This article will introduce a method of using Redis to implement distributed locks.

The principle of Redis implementing distributed locks

Redis is a high-performance key-value storage system that supports a variety of data structures. In Redis, the SET command can be used to implement distributed locks. Its implementation principle is as follows:

1. The client sends the SETNX command to Redis.

2. The Redis server processes the received SETNX command to determine whether the specified key exists. If it does not exist, set the value of the key to the client ID and set the expiration time. If it exists, failure will be returned directly.

3. The client receives the result returned by Redis and determines whether it has successfully acquired the lock. If successful, it will perform the corresponding operation. If it fails, it will wait for a period of time and then send the request again.

Steps to use Redis to implement distributed locks

1. Connect to Redis

In PHP, the PHPRedis extension is used to connect to Redis, and you need to install the extension before you can use it. For specific installation methods, please refer to the official documentation.

2. Obtain the lock

Implement a function to acquire the lock as follows:

protected function lock($lock_key, $expire_time = 5)
{
    $redis = new Redis();
    $redis->connect('localhost', 6379); // 连接Redis
    $micro_second = 1000000;
    $timeout = 10 * $micro_second; //等待锁超时时间

    while($timeout >= 0)
    {
        $microtime = microtime(true);
        $timeout -= $micro_second;
        $current_lock_time = $microtime + $expire_time + 1; //锁过期时间

        if($redis->setnx($lock_key, $current_lock_time)) //获取锁成功
        {
            $redis->expire($lock_key, $expire_time); //设置过期时间，防止死锁
            return $current_lock_time;
        }

        //检查锁是否过期
        $lock_time = $redis->get($lock_key);
        if($lock_time < $microtime)
        {
            $new_lock_time = $microtime + $expire_time + 1; //设置新的过期时间
            $old_lock_time = $redis->getset($lock_key, $new_lock_time); //获取旧的过期时间并设置新的过期时间
            if($old_lock_time < $microtime) //锁已经过期，获取锁成功
            {
                $redis->expire($lock_key, $expire_time); //设置过期时间，防止死锁
                return $new_lock_time;
            }
        }

        //等待一段时间后再次尝试获取锁
        usleep(10000); //等待10毫秒
    }

    return false;
}

The function of this function is to acquire the lock of the specified key. If the acquisition is successful, the lock will be returned. Expiration time; if the acquisition fails, return false.

3. Release the lock

Whether it is due to the completion of the operation after successfully acquiring the lock, or the failure to acquire the lock after waiting for a period of time, the lock needs to be released. Implement a function to release the lock as follows:

protected function unlock($lock_key, $current_lock_time)
{
    $redis = new Redis();
    $redis->connect('localhost', 6379); // 连接Redis
    
    $lock_time = $redis->get($lock_key);
    if($lock_time == $current_lock_time) //判断是否为当前持有锁的客户端
        $redis->del($lock_key); //释放锁
}

The function of this function is to release the lock of the specified key. Only the client currently holding the lock can release the lock.

Notes

1. The expiration time of the lock should be set reasonably according to the actual situation. If the lock expiration time is too short, the lock may expire or the lock cannot be obtained frequently; if the lock expiration time is too long, the lock expiration time may be too long, affecting system performance.

2. When setting the expiration time, be sure to prevent deadlock. If one client acquires the lock, but the lock is not released due to unexpected exit or crash, it will affect other clients to acquire the lock, causing a deadlock problem.

3. Since the implementation of distributed locks relies on the unique identifier of the client, different clients need to use different identifiers, otherwise one client may release the locks of other clients. In PHP, you can use PHP_SESSION_ID or IP address/process ID as the unique identifier of the client.

Conclusion

Using Redis to implement distributed locks is a relatively simple and practical distributed lock solution in PHP. In practical applications, it is necessary to set the lock expiration time reasonably according to the actual situation to avoid deadlock problems and ensure the stability and reliability of the system. At the same time, attention needs to be paid to ensuring the uniqueness of the client's unique identifier to avoid possible problems.

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