Redis distributed lock principle and its implementation with PHP (2)

Lock in our daily development can be used more . Usually used to solve the problem of resource concurrency . Especially in the case of multi machine cluster , The problem of resource contention . however , Many novices often make some problems in dealing with locks . Today we 're going to take a deeper look at locks .

One 、Redis One of the lock misuses

I've seen projects that store query results in Redis The pseudo code is as follows ：

$redis = new \Redis('127.0.0.1', 6379);

$cacheKey = 'query_cache';
$result = $redis->get($cacheKey);

if ($result) {
     //  If the cache is valid, it will directly return 
    return $result;
} else {
     //  If the cache fails, get it from the database and store it in the  Redis
    $mysqlResult = getDataFromDb();
    $redis->set($cacheKey, json_encode($mysqlResult), 3600);

    return $mysqlResult;
}

At first glance, the code doesn't find the problem . Usually , When the server resource pressure is very small , There's no problem with this code . also , It can really improve server throughput performance .

If , There is a single point of pressure on the code at this location ？ such as , This function is statistical result , It takes 5s. and , Because this function is commonly used , Reached in unit time 1000 Time / second .

At this time, there will be concurrency penetration problem .

1000 Requests arrive at this program location at the same time , Read whether the cache exists . If the cache does not exist at this time . this 1000 Every request will get a result that doesn't exist . And they will all go to the steps of fetching the cached results from the database . It also rewrites the result to Redis.

That leads to a single point of pressure at this instant that leads to penetration into the database , Cause database pressure to peak in an instant . If the performance of our database can't handle such a big pressure , Will cause the database server to CPU Fill up directly . The data that responds to the front end will come to a standstill .

therefore , This code is incorrect lock usage .

Two 、Redis The second wrong use of lock

In the first point , We found a problem . therefore , Someone wants to optimize it . So here's the code ：

$redis = new \Redis('127.0.0.1', 6379);

$lockKey = 'query_cache_lock'; //  Lock specific  KEY
$cacheKey = 'query_cache'; //  Store query results  KEY
$result = $redis->get($cacheKey);

if ($result) {
     //  If the cache is valid, it will directly return .
    return $result;
} else {
     //  If the cache fails, get it from the database and store it in the  Redis
    if ($redis->setNx($lockKey) === false) {
    
        throw new \Exception(" The server is hot , Please try again later ");
    } else {
    
        $mysqlResult = getDataFromDb();
        $redis->set($cacheKey, json_encode($mysqlResult), 3600);
        $redis->delete($lockKey); //  Lock out to unlock . Delete is unlock .

        return $mysqlResult;
    }
}

This code completely avoids the problem of concurrency penetration in the first point . however , Relative to the first point , The code also added a few lines . But the performance is still strong .

Even so , There are still three problems with this code ：

1. The more concurrent , The first request to get the lock can respond normally , A subsequent request will get a “ The server is hot , Please try again later ” The exception of .
2. There is no way to add a waiting time to the failure of subsequent request to take lock .
3. If the code executes to $redis->delete($lockKey) The program is abnormal . Then the lock will not release normally . Subsequent locks can't be taken normally .

For （1） spot , This is a very poor user experience .
For （2） spot , It's the solution to the first point .
For （3） spot , It's a problem we have to solve . otherwise , Our distributed locks will not work .

3、 ... and 、 Right distributed lock

The normal distributed lock should meet the following requirements ：

1. Can solve concurrent resource contention . This is the core requirement .
2. Lock can be added and released normally . No deadlocks .
3. Lock can realize waiting , Otherwise, the user experience cannot be guaranteed .

For the above three points , obtain Redis Distributed lock example

class RedisMutexLock {
    
    /** *  return  Redis  Connect  * * @return void */
    public static function getRedis() {
    
        //  Please replace this line of code with your own get according to your own project  Redis  Connect 
        return YCache::getRedisClient();
    }

    /** *  Gets the lock , If the lock is occupied , Blocking , Until the lock is obtained or the timeout is reached  * -- 1、 If  $timeout  Parameter is  0, Then immediately return to the lock  * -- 2、 Suggest  timeout  Set to  0, avoid  redis  Performance degradation due to congestion. Please set it according to actual requirements  * * @param string $key  cache KEY * @param int $timeout  Lock taking timeout unit ( second ) be equal to 0, If the current lock is occupied , Immediately return failure if greater than 0, Then repeatedly try to acquire the lock until the timeout is reached  * @param int $lockSecond  Lock time unit ( second ) * @param int $sleep  Lock taking interval unit ( Microsecond ) When the lock is in the occupied state, how often do you try to get the lock by default  0.1  Take the lock every second  * @return bool  success :true、 Failure :false */
    public static function lock($key, $timeout = 0, $lockSecond = 20, $sleep = 100000) {
    
        if (strlen($key) === 0) {
    
            //  Project throw exception method 
            YCore::exception(500, ' cache KEY No settings ');
        }

        $start = self::getMicroTime();
        $redis = self::getRedis();

        do {
    
            // [1]  The lock  KEY  It is not important to set its value when it does not exist and set the expiration time to the value of the specified time lock. What is important is to use  Redis  Characteristics of 
            $acquired = $redis->set("Lock:{
      $key}", 1, ['NX', 'EX' => $lockSecond]);
            if ($acquired) {
    
                break;
            }
            if ($timeout === 0) {
    
                break;
            }
            usleep($sleep);
        } while (!is_numeric($timeout) || (self::getMicroTime()) < ($start + ($timeout * 1000000)));

        return $acquired ? true : false;
    }

    /** *  Release the lock  * * @param mixed $key  Locked KEY * @return void */
    public static function release($key) {
    
        if (strlen($key) === 0) {
    
            //  Project throw exception method 
            YCore::exception(500, ' cache KEY No settings ');
        }
        
        $redis = self::getRedis();
        $redis->del("Lock:{
      $key}");
    }

    /** *  Get the current microsecond  * * @return bigint */
    protected static function getMicroTime() {
    
        return bcmul(microtime(true), 1000000);
    }
}

from ：https://www.phpernote.com/redis/1621.html