How to prevent concurrent repeated writing in PHP

This time I will show you how PHP prevents concurrent repeated writing, and what are the precautions for PHP to prevent concurrent repeated writing. The following is a practical case, let's take a look.

1. Write in front:

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

In order to prevent this situation from causing abnormal impact on the system, we implemented a simple document lock through Redis. Each request needs to obtain the lock before executing the business logic, and the lock will be released after the execution is completed; ensuring the same document For concurrent repeated operation requests, only one request can obtain the lock (relying on Redis's single thread), which is a pessimistic lock design;

Note: Redis locks are generally only used to solve concurrent repetitions in our system. In the case of requests, for non-concurrent repeated requests, the status of the data will generally be verified in the database or log. The combination of the two mechanisms can ensure the reliability of the entire link.

2. Locking mechanism:

Mainly relies on Redis setnx instruction implementation:

But using setnx has One problem is that the setnx instruction does not support setting the expiration time. You need to use the expire instruction 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 program exits abnormally, resulting in failure. Successfully setting the timeout may lead to deadlock if it is not unlocked in time (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, and the setnx and expire instructions are executed as an atomic operation, but this will be relatively troublesome. Fortunately, in versions after Redis 2.6.12, the Redis set instruction supports nx, ex mode, and supports atomically setting the 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, [&#39;nx&#39;, &#39;ex&#39;=>$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 unlocking the entire The process also needs to ensure atomicity, which 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), the subsequent The transaction 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)

5. Unlocking Implementation (Complete The 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)

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，解锁失败

I believe you have read the case in this article You have mastered the method. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Detailed explanation of the steps to set up web cluster session synchronization in PHP

Detailed explanation of the steps to implement large file cutting and merging in PHP

The above is the detailed content of How to prevent concurrent repeated writing in PHP. For more information, please follow other related articles on the PHP Chinese website!