PHP implements Redis document lock and prevents concurrent repeated writing

The content of this article is to share with you PHP's implementation of Redis document lock and prevention of concurrent repeated writing. It has a certain reference value. Friends in need can refer to it.

1. Write in Previous:
In the entire supply chain system, there will be many kinds of documents (purchase orders, warehousing orders, arrival orders, waybills, etc.), when it comes to the interface for writing document data (add, delete, modify operations) , even if the front-end has made relevant restrictions, it is still possible that concurrent repeated calls may occur due to network or abnormal operations, resulting in the same processing of the same documents;

In order to prevent this situation from causing abnormal impact on the system, we A simple document lock is implemented through Redis. Each request needs to acquire the lock before executing the business logic, and the lock will be released after the execution is completed; it is guaranteed that only one request for concurrent repeated operation requests of the same document can acquire the lock (relying on Redis) Single thread) is a pessimistic lock design;

Note: Redis lock is generally only used to solve concurrent repeated requests in our system. For non-concurrent repeated requests, it will generally go to the database or Log verification data status, the combination of the two mechanisms can ensure the reliability of the entire link.

2. Locking mechanism:
Mainly relies on the Redis setnx command to implement:

But there is a problem with using setnx, that is, the setnx command does not support setting For the expiration time, you need to use the expire command to set a timeout for the key. In this way, the entire locking operation is not an atomic operation. It is possible that the setnx lock is successful, but the timeout is not successfully set due to the abnormal exit of the program, and the lock is not unlocked in time. In this case, it may lead to deadlock (even if deadlock does not occur in the business scenario, it is not a good design for useless keys to remain in memory);

This situation can be solved using Redis transactions , execute the setnx and expire instructions as an atomic operation, but doing so will be relatively troublesome. Fortunately, in versions after Redis 2.6.12, the Redis set instruction supports nx and ex modes, and supports atomic settings. Expiration time:

3. Locking implementation (the complete test code will be posted at the end):

  /**
     * 加单据锁
     * @param int $intOrderId 单据ID
     * @param int $intExpireTime 锁过期时间（秒）
     * @return bool|int 加锁成功返回唯一锁ID，加锁失败返回false
     */
    public static function addLock($intOrderId, $intExpireTime = self::REDIS_LOCK_DEFAULT_EXPIRE_TIME)
    {
        //参数校验
        if (empty($intOrderId) || $intExpireTime <= 0) {            return false;
        }        //获取Redis连接
        $objRedisConn = self::getRedisConn();        //生成唯一锁ID，解锁需持有此ID
        $intUniqueLockId =  self::generateUniqueLockId();        //根据模板，结合单据ID，生成唯一Redis key（一般来说，单据ID在业务中系统中唯一的）
        $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId);        //加锁（通过Redis setnx指令实现，从Redis 2.6.12开始，通过set指令可选参数也可以实现setnx，同时可原子化地设置超时时间）
        $bolRes = $objRedisConn->set($strKey, $intUniqueLockId, ['nx', 'ex'=>$intExpireTime]);        //加锁成功返回锁ID，加锁失败返回false
        return $bolRes ? $intUniqueLockId : $bolRes;
    }

4. Unlocking mechanism:
Unlocking means comparing the unique lock id when locking. If the comparison is successful, the key will be deleted. It should be noted that the entire unlocking process also needs to ensure atomicity. This relies on the watch and transaction implementation of redis;

The WATCH command can monitor one or more keys. Once one of the keys is modified (or deleted), subsequent transactions will not be executed. Monitoring continues until the EXEC command (commands in the transaction are executed after EXEC, so the key value of WATCH monitoring can be modified after the MULTI command)
For Redis watch and transactions, please refer to the short book article: https://www.jianshu.com/p/361cb9cd13d5

5. Unlocking implementation (the complete test code will be posted at the end):

/**
     * 解单据锁
     * @param int $intOrderId 单据ID
     * @param int $intLockId 锁唯一ID
     * @return bool
     */
    public static function releaseLock($intOrderId, $intLockId)
    {
        //参数校验
        if (empty($intOrderId) || empty($intLockId)) {            return false;
        }        //获取Redis连接
        $objRedisConn = self::getRedisConn();        //生成Redis key
        $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId);        //监听Redis key防止在【比对lock id】与【解锁事务执行过程中】被修改或删除，提交事务后会自动取消监控，其他情况需手动解除监控
        $objRedisConn->watch($strKey);        if ($intLockId == $objRedisConn->get($strKey)) {            $objRedisConn->multi()->del($strKey)->exec();            return true;
        }        $objRedisConn->unwatch();        return false;
    }

6. Attached is the overall test code (this code is only a simple version)

set($strKey, $intUniqueLockId, ['nx', 'ex'=>$intExpireTime]);        //加锁成功返回锁ID，加锁失败返回false
        return $bolRes ? $intUniqueLockId : $bolRes;
    }    /**
     * 解单据锁
     * @param int $intOrderId 单据ID
     * @param int $intLockId 锁唯一ID
     * @return bool
     */
    public static function releaseLock($intOrderId, $intLockId)
    {        //参数校验
        if (empty($intOrderId) || empty($intLockId)) {            return false;
        }        //获取Redis连接
        $objRedisConn = self::getRedisConn();        //生成Redis key
        $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId);        //监听Redis key防止在【比对lock id】与【解锁事务执行过程中】被修改或删除，提交事务后会自动取消监控，其他情况需手动解除监控
        $objRedisConn->watch($strKey);        if ($intLockId == $objRedisConn->get($strKey)) {
            $objRedisConn->multi()->del($strKey)->exec();            return true;
        }
        $objRedisConn->unwatch();        return false;
    }    /**
     * Redis配置：IP
     */
    const REDIS_CONFIG_HOST = '127.0.0.1';    /**
     * Redis配置：端口
     */
    const REDIS_CONFIG_PORT = 6379;    /**
     * 获取Redis连接（简易版本，可用单例实现）
     * @param string $strIp IP
     * @param int $intPort 端口
     * @return object Redis连接
     */
    public static function getRedisConn($strIp = self::REDIS_CONFIG_HOST, $intPort = self::REDIS_CONFIG_PORT)
    {
        $objRedis = new Redis();
        $objRedis->connect($strIp, $intPort);        return $objRedis;
    }    /**
     * 用于生成唯一的锁ID的redis key
     */
    const REDIS_LOCK_UNIQUE_ID_KEY = 'lock_unique_id';    /**
     * 生成锁唯一ID（通过Redis incr指令实现简易版本，可结合日期、时间戳、取余、字符串填充、随机数等函数，生成指定位数唯一ID）
     * @return mixed
     */
    public static function generateUniqueLockId()
    {        return self::getRedisConn()->incr(self::REDIS_LOCK_UNIQUE_ID_KEY);
    }
}//test$res1 = Lock_Service::addLock('666666');
var_dump($res1);//返回lock id，加锁成功$res2 = Lock_Service::addLock('666666');
var_dump($res2);//false，加锁失败$res3 = Lock_Service::releaseLock('666666', $res1);
var_dump($res3);//true，解锁成功$res4 = Lock_Service::releaseLock('666666', $res1);
var_dump($res4);//false，解锁失败

Blog moving: https://segmentfault.com/blog/leeonfancy

Related recommendations:

php configuration and instructions for extending redis under windows

Sharing of php commands to operate redis

Detailed explanation of redis memory lock and PHP preventing concurrent operations

The above is the detailed content of PHP implements Redis document lock and prevents concurrent repeated writing. For more information, please follow other related articles on the PHP Chinese website!