PHP utilise le verrouillage Redis pour limiter l'exemple de classe d'accès simultané

Cet article présente l'utilisation des verrous Redis en PHP pour limiter les classes d'accès simultanés et présente en détail les méthodes de restriction d'accès simultané.

1. Problèmes de restriction d'accès simultanés

Pour certains scénarios où l'accès simultané du même utilisateur doit être restreint, si l'utilisateur demande simultanément plusieurs fois et que le serveur Le processus n'a aucune restriction de verrouillage, l'utilisateur peut demander avec succès plusieurs fois.

Par exemple, lors de l'échange de coupons, si l'utilisateur soumet le code d'échange simultanément en même temps, l'utilisateur peut utiliser le même code d'échange pour utiliser plusieurs coupons en même temps sans restrictions de verrouillage.

Le pseudo code est le suivant :

si A (peut être échangé)
B (le rachat est exécuté)
C (mis à jour pour avoir été échangé)
D (Fin)

Si les utilisateurs soumettent des codes d'échange simultanément, ils peuvent tous être jugés comme échangeables (A), car il faut exécuter l'échange (B) avant qu'il ne soit mis à jour pour utiliser le collier ( C). Par conséquent, si l'utilisateur effectue plusieurs demandes avant qu'une mise à jour ne soit disponible, ces demandes peuvent être exécutées avec succès.

2. Méthode de restriction d'accès simultané

L'utilisation de verrous de fichiers peut obtenir des restrictions d'accès simultanées, mais pour les environnements d'architecture distribuée, l'utilisation de verrous de fichiers ne peut pas garantir des restrictions d'accès simultanées sur plusieurs serveurs.

Redis est une base de données de valeurs-clés de type journal open source écrite en langage ANSI C, prend en charge le réseau, peut être basée sur la mémoire et persistante, et fournit des API dans plusieurs langues.

Cet article utilisera sa méthode setnx pour implémenter la fonction de verrouillage distribué. setnx est Set it N**not eX**ists.

Lorsque la valeur de la clé n'existe pas, l'insertion est réussie (le verrou est acquis avec succès). Si la valeur de la clé existe déjà, l'insertion échoue (l'acquisition du verrou échoue)

RedisLock.class.PHP

<?php
/**
 * Redis锁操作类
 * Date:  2016-06-30
 * Author: fdipzone
 * Ver:  1.0
 *
 * Func:
 * public lock  获取锁
 * public unlock 释放锁
 * private connect 连接
 */
class RedisLock { // class start
 
  private $_config;
  private $_redis;
 
  /**
   * 初始化
   * @param Array $config redis连接设定
   */
  public function __construct($config=array()){
    $this->_config = $config;
    $this->_redis = $this->connect();
  }
 
  /**
   * 获取锁
   * @param String $key  锁标识
   * @param Int   $expire 锁过期时间
   * @return Boolean
   */
  public function lock($key, $expire=5){
    $is_lock = $this->_redis->setnx($key, time()+$expire);
 
    // 不能获取锁
    if(!$is_lock){
 
      // 判断锁是否过期
      $lock_time = $this->_redis->get($key);
 
      // 锁已过期，删除锁，重新获取
      if(time()>$lock_time){
        $this->unlock($key);
        $is_lock = $this->_redis->setnx($key, time()+$expire);
      }
    }
 
    return $is_lock? true : false;
  }
 
  /**
   * 释放锁
   * @param String $key 锁标识
   * @return Boolean
   */
  public function unlock($key){
    return $this->_redis->del($key);
  }
 
  /**
   * 创建redis连接
   * @return Link
   */
  private function connect(){
    try{
      $redis = new Redis();
      $redis->connect($this->_config[&#39;host&#39;],$this->_config[&#39;port&#39;],$this->_config[&#39;timeout&#39;],$this->_config[&#39;reserved&#39;],$this->_config[&#39;retry_interval&#39;]);
      if(empty($this->_config[&#39;auth&#39;])){
        $redis->auth($this->_config[&#39;auth&#39;]);
      }
      $redis->select($this->_config[&#39;index&#39;]);
    }catch(RedisException $e){
      throw new Exception($e->getMessage());
      return false;
    }
    return $redis;
  }
 
} // class end
 
?>

demo.php

<?php
require &#39;RedisLock.class.php&#39;;
 
$config = array(
  &#39;host&#39; => &#39;localhost&#39;,
  &#39;port&#39; => 6379,
  &#39;index&#39; => 0,
  &#39;auth&#39; => &#39;&#39;,
  &#39;timeout&#39; => 1,
  &#39;reserved&#39; => NULL,
  &#39;retry_interval&#39; => 100,
);
 
// 创建redislock对象
$oRedisLock = new RedisLock($config);
 
// 定义锁标识
$key = &#39;mylock&#39;;
 
// 获取锁
$is_lock = $oRedisLock->lock($key, 10);
 
if($is_lock){
  echo &#39;get lock success<br>&#39;;
  echo &#39;do sth..<br>&#39;;
  sleep(5);
  echo &#39;success<br>&#39;;
  $oRedisLock->unlock($key);
 
// 获取锁失败
}else{
  echo &#39;request too frequently<br>&#39;;
}
 
?>

Méthode de test :

Ouvrez deux navigateurs différents et accédez à demo.php en A et B en même temps

Si vous y accédez en premier, vous obtiendrez le verrou

Sortie

obtenir le succès du verrouillage
faire qc..
succès

Si un autre verrouillage d'acquisition échoue, une demande trop fréquente sera sortie

pour garantir le même temps Un seul accès est valide, limitant efficacement les accès simultanés.

Afin d'éviter les blocages causés par des erreurs soudaines du système, un délai d'expiration est ajouté lors de l'acquisition du verrou. Si le délai d'expiration est dépassé, le verrou sera libéré même à l'état verrouillé pour éviter les problèmes causés par un blocage. .

Pour plus d'articles liés à PHP sur l'utilisation du verrouillage Redis pour limiter les exemples d'accès simultanés, veuillez faire attention au site Web PHP chinois !