Analyse des étapes de traitement à haute concurrence des fichiers de lecture et d'écriture PHP

Cette fois, je vais vous apporter une analyse des étapes de fonctionnement du traitement hautement simultané des fichiers de lecture et d'écriture PHP. Quelles sont les précautions pour le traitement hautement simultané des fichiers de lecture et d'écriture PHP. Ce qui suit est un cas pratique.

Récemment, le développement de jeux d'entreprise a besoin de connaître le taux de désabonnement lors du chargement des jeux. Parce que nous créons des jeux Web. Quiconque a joué à des jeux Web sait que vous devez charger certaines ressources avant d'entrer dans le jeu. Enfin, vous pouvez accéder à l'interface du jeu pour créer un personnage. L'un de nos besoins est de compter le nombre d'utilisateurs perdus avant d'atteindre l'interface de création de personnage lors du processus de chargement.

Nous comptons le nombre de personnes au début du chargement, puis enregistrons le nombre de personnes une fois le chargement terminé. De cette façon, en soustrayant le nombre de personnes après un chargement réussi du nombre de personnes avant le chargement. Connaissez simplement le taux de désabonnement des chargements. Vous pouvez savoir si le jeu doit continuer à optimiser le processus de chargement et à réduire le taux de chargement du jeu par l'utilisateur.

Parce que notre trafic est importé des médias coopératifs les plus mainstream. La simultanéité est donc très élevée, selon des calculs approximatifs, elle devrait pouvoir atteindre environ 1 000 simultanéités par seconde.

Le nombre de personnes avant le chargement était initialement prévu pour être placé sur la plateforme de mise en cache au sein du jeu. Cependant, les collègues du backend du jeu craignent que la concurrence soit trop élevée, ce qui entraînerait un gaspillage inutile de ressources. Car la libération de mémoire ne répond pas en temps réel. Mettez donc le nombre de personnes comptées sur un autre serveur : le serveur de statistiques.

La solution que je viens de commencer à utiliser est la suivante :

Par le biais du <a href="http://www.php.cn/wiki/1311.html" target="de" php _blank>file_get_contents<p style="text-align: left;">()</p></a> et <a href="http://www.php.cn/wiki/1312.html" target="_blank">file_put_contents<code><a href="http://www.php.cn/wiki/1311.html" target="_blank">file_get_contents</a>()( ) Lire et écrire. La première fois que vous lisez et écrivez, écrivez 1 dans le fichier, la deuxième fois que vous chargez, ajoutez 1 à l'original, et ainsi de suite. Il n'y a aucun problème avec cette séquence d'idées. Le problème réside dans le fait que notre serveur ne peut pas être séquentiel. <a href="http://www.php.cn/wiki/1312.html" target="_blank">file_put_contents</a>()Pour être précis, l’accès concurrent n’est pas séquentiel. Lorsque le joueur A charge le jeu et lit le nombre 100 dans le fichier (en supposant qu'il soit 100 à ce moment-là), le joueur B lit également 100. À ce moment, le joueur de traitement de thread A ajoute 1 à 100 pour obtenir 101. écrira 101. au fichier.

Le lecteur de traitement de thread B obtient également le même résultat, en écrivant 101 dans le fichier. A ce moment-là, le problème se pose ? Le joueur B a chargé le jeu après le joueur A, il devrait donc obtenir un résultat de calcul de 102.

C'est le problème causé par la concurrence. À ce moment-là, j'ai pensé à utiliser

pour ouvrir le fichier et à utiliser fopen() pour ajouter un verrou en écriture. Tout le monde pensera certainement que si cette méthode est verrouillée, cela ne posera pas de problèmes. En fait, c’est également faux. flock()

Parce que notre problème n'est pas l'écriture. Au lieu de cela, cela entraîne une désynchronisation des données lors de la lecture. D'ACCORD. À ce stade, je n'arrive vraiment pas à comprendre avec Baidu et Google.

Lorsque mes espoirs reposaient sur la fonction PHP elle-même et que mes rêves se sont brisés, je n'ai pu trouver qu'un autre moyen. Sortez-en. J'ai donc pensé au mécanisme de mappage Map du langage *. Semblable à notre tableau PHP, j'ajoute un élément au tableau à chaque fois qu'il est chargé. De cette façon, au final, il me suffit de

cliquer sur le tableau pour savoir combien de joueurs ont chargé le jeu. count()

Cependant, il y a un problème lors de l'utilisation de tableaux. Même les

variables PHP sont toujours constantes et seront effacées une fois le script exécuté. J'ai donc réfléchi à la façon de sauvegarder des fichiers.

La solution finale réalisable est la suivante :

Utilisez fopen pour ouvrir un fichier en mode écriture seule. Puis écrivez lock. Chaque fois qu'un joueur charge, j'écris un numéro 1 dans le fichier. Le contenu final du fichier est lu immédiatement via

, puis la longueur est calculée à l'aide de file_get_contents() pour savoir combien de joueurs ont chargé le jeu. strlen()

J'ai entendu dire que la fonction

serait verrouillée, ce qui entraînerait une augmentation des ressources système pendant une longue période. Par conséquent, j'ai adopté la méthode utilisée par tout le monde et utilisé la technologie de délai d'attente de la microseconde pour résoudre ce problème. Si je sors de ce temps, je le jetterai. Le code spécifique est le suivant : flock()

// loadcount.func.php 函数文件。
/**
 * 获取某来源和某服务器ID的游戏加载次数。
 *
 * @param string $fromid 来源标识。
 * @param int $serverid 服务器ID编号。
 *
 * @return int
 */
function getLoadCount($fromid, $serverid)
{
    global $g_global;
    $serverid = (int) $serverid;
    $fromid  = md5($fromid);
    $filename = $fromid . $serverid . '.txt';
    $data = file_get_contents($filename);
    return strlen($data);
}
/**
 * 获取某来源所有服务器的游戏加载次数。
 *
 * @param string $fromid 来源标识。
 *
 * @return int
 */
function getAllLoadCount($fromid)
{
    global $g_global;
    $fromid  = md5($fromid);
    $count = 0;
    foreach (glob("{$fromid}*.txt") as $filename)
    {
        $file_content = file_get_contents($filename);
        $count += strlen($file_content);
    }
    return $count;
}
/**
 * 清空所有的加载数据。
 *
 * @return void
 */
function clearLoadCount()
{
    foreach (glob("*.txt") as $filename) {
      unlink($filename);
    }
    return true;
}
/**
 * 延迟更新游戏加载次数中间件。
 *
 * 使用此函数来延迟更新数据，原理：当不足1000次的时候，不更新数据库，超过1000就更新到数据库里面去。
 *
 * @param string $fromid 来源标识。
 * @param int $serverid 服务器ID编号。
 */
function delayAddLoadCount($fromid, $serverid)
{
    // 使用MD5生成文件名记录缓存次数。
    $fromid  = md5($fromid);
    $filename = $fromid . $serverid . '.txt';
    if($fp = fopen($filename, 'a'))
    {
        $startTime = microtime();
        do {
            $canWrite = flock($fp, LOCK_EX);
            if(!$canWrite)
            {
                usleep(round(mt_rand(0, 100)*1000));
            }
        }
        while ( ( !$canWrite ) && ( ( microtime()- $startTime ) < 1000 ) );
        if ($canWrite)
        {
            fwrite($fp, "1");
        }
        fclose($fp);
    }
    return true;
}

Voici le fichier dans lequel j'ai appelé la méthode ci-dessus :

< ?php
/**
 * @describe 平台用户加载游戏次数统计接口入口。
 * @date 2012.12.17
 */
include_once &#39;./loadcount.func.php&#39;;
// 测试用。
// $_GET[&#39;fromid&#39;]  = &#39;4399&#39;;
// $_GET[&#39;serverid&#39;] = mt_rand(0, 5);
// 添加加载次数。
if ( $_GET[&#39;action&#39;] == &#39;addcount&#39; )
{
    $fromid  = $_GET[&#39;fromid&#39;];  // 来源标识。
    $serverid = $_GET[&#39;serverid&#39;]; // 服务器ID编号。
    $return = delayAddLoadCount($fromid, $serverid);
    $return = $return ? 1 : 0;
    ob_clean();
    echo json_encode($return);
    exit;
}
// 取加载次数。
elseif ( $_GET[&#39;action&#39;] == &#39;getcount&#39; )
{
    $fromid = $_GET[&#39;fromid&#39;];  // 来源标识。
    if ( !isset( $_GET[&#39;serverid&#39;] ) ) // 有服务器编号 ID则取来源对应的服务器加载次数。
    {
        $count = getAllLoadCount($fromid);
    }
    else // 加载对应来源的次数。
    {
        $serverid = $_GET[&#39;serverid&#39;]; // 服务器ID编号。
        $count = getLoadCount($fromid, $serverid);
    }
    ob_clean();
    header(&#39;Content-Type:text/html;charset=UTF-8&#39;);
    $serverid = strlen($serverid) ? $serverid : &#39;无&#39;;
    echo "来源:{$fromid},服务器ID:{$serverid},游戏加载次数：" . $count;
    exit;
}
// 清除加载次数。
elseif ( $_GET[&#39;action&#39;] == &#39;clearcount&#39; )
{
    header(&#39;Content-Type:text/html;charset=UTF-8&#39;);
    $return = clearLoadCount();
    if ($return)
    {
        echo "清除成功！";
    }
    else
    {
        echo "清除失败！";
    }
}

C'est une foutue leçon, je dois donc l'enregistrer . Pour que d’autres puissent en tirer des leçons à l’avenir.

Cet article est le code écrit par l'auteur Han Bing il y a un an alors qu'il était responsable de l'analyse des données chez 4399 Game Studio. J'espère que cela aide tout le monde.

PHP数据库操作之高并发实例

高并发下PHP写文件日志丢失

<?php
/**
 * Created by PhpStorm.
 * User: andyfeng
 * Date: 2015/6/24
 * Time: 13:31
 */
class LogFileUtil {
  public static $fileHandlerCache;
  private static $initFlag = false;
  private static $MAX_LOOP_COUNT = 3;
  private static function init() {
    self::$initFlag = true;
    register_shutdown_function(array("LogFileUtil", "shutdown_func"));
  }
  /**
   * 输出到文件日志
   * @param $filePath 文件路径
   * @param $msg 日志信息
   * @return int
   */
  public static function out($filePath, $msg) {
    if (!self::$initFlag) {
      self::init();
    }
    return self::internalOut($filePath, $msg);
  }
  /**
   * @param $filePath
   * @param $msg
   * @param $loop
   * @return int
   */
  private static function internalOut($filePath, $msg, $loop = 0) {
    //以防一直添加失败造成死循环
    if ($loop > self::$MAX_LOOP_COUNT) {
      $result = 0;
    } else {
      $loop++;
      $fp = self::$fileHandlerCache["$filePath"];
      if (empty($fp)) {
        $fp = fopen($filePath, "a+");
        self::$fileHandlerCache[$filePath] = $fp;
      }
      if (flock($fp, LOCK_EX)) {
        $result = fwrite($fp, $msg);
        flock($fp, LOCK_UN);
      } else {
        $result = self::internalOut($filePath, $msg, $loop);
      }
    }
    return $result;
  }
  function shutdown_func() {
    if (!empty(LogFileUtil::$fileHandlerCache)) {
      if (is_array(LogFileUtil::$fileHandlerCache)) {
        foreach (LogFileUtil::$fileHandlerCache as $k => $v) {
          if (is_resource($v))
            //file_put_contents("close.txt",$k);
            fclose($v);
        }
      }
    }
  }
}

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

PHP动态创建XML文档步骤详解

php怎样快速生成无限级分类（附代码）

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!