PHP utilise simplement la fonction shmop pour créer de la mémoire partagée afin de réduire la charge du serveur

Cet article présente principalement comment PHP utilise simplement la fonction shmop pour créer de la mémoire partagée afin de réduire la charge du serveur. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

. Dans l'article précédent Ce blog [Comprendre le concept, les avantages et les inconvénients de la mémoire partagée] a déjà expliqué le concept de mémoire partagée. Utilisons simplement la mémoire partagée (en fait, vous pouvez également utiliser d'autres outils, comme redis)

PHP dispose de deux ensembles d'interfaces pour le partage de mémoire. L'un est shm, qui est en fait un partage de variables et sérialisera les variables d'objet avant de les stocker. Il est assez pratique à utiliser, mais le stockage sérialisé n'a aucun sens pour les opérations d'accès à la mémoire qui privilégient l'efficacité. L'autre est shmop, qui est commun à Linux et Windows, mais sa fonction est plus faible que shm Sous Linux, ces fonctions sont directement implémentées en appelant la série de fonctions shm*, tandis que sous Winodows, elles sont également implémentées par le système d'encapsulation. fonctions. a fait le même appel. Ce que j'utilise ici en premier, c'est shmop.

Pour créer un segment de mémoire partagée, vous devez utiliser la fonction shmop, puis vous devez activer l'extension. Vous pouvez vous référer à [Activer l'extension shmop pour PHP pour implémenter la mémoire partagée].

La fonction principale de shmop

shmop_open (créer ou ouvrir un bloc de mémoire partagée), shmop_write (écrire des données dans un bloc de mémoire partagée), shmop_read (lire des données à partir d'un bloc de mémoire partagée) , shmop_size (obtenir la taille d'un bloc de mémoire partagée), shmop_close (fermer le bloc de mémoire partagée), shmop_delete (supprimer un bloc de mémoire partagée)

<?php
//创建一块共享内存
$shm_key = 0x4337b101;
$shm_id = @shmop_open($shm_key, &#39;c&#39;, 0644, 1024);
//读取并写入数据
$data = shmop_read($shm_id, 0, 1024);
shmop_write($shm_id, json_encode($data), 0);
$size = shmop_size($shm_id);  //获取内存中实际数据占用大小
//关闭内存块，并不会删除共享内存，只是清除 PHP 的资源
shmop_close($shm_id);

shmop_open (créer un segment de mémoire)

Le premier qui apparaît dans cette fonction. Le problème est le paramètre ID système. Il s'agit d'un numéro qui identifie le segment de mémoire partagée dans le système. Le deuxième paramètre est le mode d'accès, qui est très similaire au mode d'accès de la fonction fopen. Vous pouvez accéder à un segment mémoire selon 4 modes différents :

mode "a", qui permet d'accéder aux segments mémoire en lecture seule, accès en lecture seule

mode "w", qui permet d'accéder segments de mémoire en lecture seule Segment de mémoire pour la lecture et l'écriture, lecture et écriture
mode "c", il crée un nouveau segment de mémoire, ou si le segment de mémoire existe déjà, essayez de l'ouvrir pour la lecture et l'écriture
mode "n", cela crée une nouvelle mémoire. Si le segment avec la même clé existe déjà, la création échouera dans un souci d'utilisation sûre de la mémoire partagée.
Le troisième paramètre est l'autorisation du segment mémoire. Vous devez fournir une valeur octale ici.

Le quatrième paramètre fournit la taille du segment mémoire en octets. Étant donné que le segment de mémoire partagée utilisé est de longueur fixe, la longueur des données doit être calculée lors du stockage et de la lecture, sinon l'écriture risque d'échouer ou une valeur nulle peut être lue. .

Notez que cette fonction renvoie un numéro d'identification qui peut être utilisé par d'autres fonctions pour opérer sur ce segment de mémoire partagée. Cet ID est l'ID d'accès à la mémoire partagée, contrairement à l'ID système, qui est passé en paramètre. Attention à ne pas confondre les deux. En cas d'échec, shmop_open retournera FALSE. Lors de la création d'un bloc mémoire, il est recommandé d'utiliser des constantes au lieu de variables pour le paramètre clé, sinon cela risque de provoquer des fuites de mémoire.

shmop_write (écrire des données dans le segment mémoire)

Cette fonction est similaire à la fonction fwrite, qui a deux paramètres : la ressource de flux ouvert (renvoyée par fopen) et les données que vous souhaitez écrire. La fonction shmop_write effectue également cette tâche.

Le premier paramètre est l'ID renvoyé par shmop_open, qui identifie le bloc de mémoire partagée sur lequel vous opérez. Le deuxième paramètre correspond aux données que vous souhaitez stocker et le troisième paramètre final est la position où vous souhaitez commencer l'écriture. Par défaut, nous utilisons toujours 0 pour indiquer par où commencer l'écriture. Notez que cette fonction renvoie FALSE en cas d'échec et le nombre d'octets écrits en cas de succès.

shmop_read (lire les données du segment de mémoire)

La lecture des données du segment de mémoire partagée est simple. Tout ce dont vous avez besoin est un segment de mémoire ouvert et la fonction shmop_read. Cette fonction accepte certains paramètres et fonctionne comme fread.

Veuillez faire attention aux paramètres ici. La fonction shmop_read acceptera l'ID renvoyé par shmop_open, que nous connaissons déjà, mais elle acceptera également deux autres paramètres. Le deuxième paramètre est l'emplacement dans le segment de mémoire à partir duquel vous souhaitez lire, et le troisième est le nombre d'octets que vous souhaitez lire. Le deuxième paramètre peut toujours être 0, indiquant le début des données, mais le troisième paramètre peut être problématique car nous ne savons pas combien d'octets nous voulons lire.

C'est très similaire à ce que nous faisons dans la fonction fread, qui accepte deux paramètres : la ressource du flux ouvert (renvoyée par fopen) et le nombre d'octets que vous souhaitez lire dans le flux. Utilisez la fonction filesize (qui renvoie le nombre d'octets dans un fichier) pour le lire complètement.

shmop_size (renvoie la taille réelle des données du segment mémoire)

Par exemple, nous avons ouvert un espace mémoire d'une longueur de 100 octets, mais la longueur réelle des données stockées n'est que de 90, alors la valeur renvoyée en utilisant shmop_size est de 90.

shmop_delete (supprimer le segment de mémoire)

该函数仅接受一个参数：我们希望删除的共享内存 ID，这不会实际删除该内存段。它将该内存段标记为删除，因为共享内存段在有其他进程正在使用它时无法被删除。shmop_delete 函数将该内存段标记为删除，阻止任何其他进程打开它。要删除它，我们需要关闭该内存段。在创建内存块时建议key参数用常量而不用变量，否则很有可能造成内存泄露。

shmop_close(关闭内存段)

我们在对内存段进行读取和写入，但完成操作后，我们必须从它解除，这非常类似于处理文件时的 fclose 函数。打开包含一个文件的流并在其中读取或写入数据后，我们必须关闭它，否则将发生锁定。

简单测试结果查看

我是在LNMP环境下操作的，如果你也和我一样，在执行完简单的操作之后，可以使用linux命令查看一下地址和占用大小

# ipcs -m

[root@bogon ~]# ipcs -m

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          　　　 gdm              600                 393216            2         dest         
0x00000000 32769             gdm              600                 393216            2         dest                              
0x4337b101 884750           nobody         644                 1024                0

命令说明

key ：共享内存的唯一的key值，共享内存通过该key来判断你读取的是哪一块内存。
shmid：当使用key来获取内存时，你获得的是这个id的值。它作为你操作内存块的标识。
owner：创建该共享内存块的用户
perms：该共享内存的读写权限，8禁止，可以是777，与文件的读写权限一致。
bytes：该内存块的大小
nattch：连接该内存块的进程数
status：当前状态，如：dest，即将删除等。

项目实际应用小案例

<?php
/**
 * 将领技能
 */
class Generalskill_model extends CI_Model {
  
  private $_memory_key = 0x4337b001;   //共享内存地址key
  private $_memory_size = 1048576;     //开辟共享内存大小  //最好根据实际数据长度大小定义。

  public function __construct() {
    parent::__construct();
  }

  public function get_skill_list() {
    $data = [];
    $shmid = @shmop_open($this->_memory_key, &#39;a&#39;, 0644, $this->_memory_size);  

    if ($shmid === FALSE) {
        $shmid = @shmop_open($this->_memory_key, &#39;c&#39;, 0644, $this->_memory_size);  
        $data = $this->return_skill_list();
        shmop_write($shmid, json_encode($data), 0); 
        @shmop_close($shmid);

        return $data;
    }
    $data = json_decode(preg_replace(&#39;/[\x00-\x1F\x80-\x9F]/u&#39;, &#39;&#39;, trim(shmop_read($shmid, 0, $this->_memory_size))), true);
    @shmop_close($shmid);
    return $data;    
  
  }

  public function return_skill_list() {   //这里是一个超大的数组，其实就是把这个数组json化，然后存入共享内存段。  其实可以用redis等其他缓存...这里我就是为了不用redis等其他nosql才用的shmop
    return array (
  1 => 
  array (&#39;id&#39; => &#39;1&#39;,&#39;animation&#39; => &#39;13&#39;,&#39;skill_type&#39; => &#39;1&#39;,&#39;power_type&#39; => &#39;1&#39;,&#39;site&#39; => &#39;1&#39;,&#39;type&#39; => &#39;1&#39;,&#39;paramete&#39; => &#39;0&#39;,&#39;paramete2&#39; => &#39;0&#39;,&#39;paramete3&#39; => &#39;0&#39;,&#39;chance&#39; => &#39;0&#39;,&#39;ratio&#39; => &#39;1&#39;,
  ),
  2 => 
  array (&#39;id&#39; => &#39;2&#39;,&#39;animation&#39; => &#39;3&#39;,&#39;skill_type&#39; => &#39;2&#39;,&#39;power_type&#39; => &#39;1&#39;,&#39;site&#39; => &#39;1&#39;,&#39;type&#39; => &#39;1&#39;,&#39;paramete&#39; => &#39;0&#39;,&#39;paramete2&#39; => &#39;0&#39;,&#39;paramete3&#39; => &#39;0&#39;,&#39;chance&#39; => &#39;0&#39;,&#39;ratio&#39; => &#39;2&#39;,
  ),..........................................

当然你要考虑的是，如果数据更新的话，那么内存段也要删除，并且更新数据......................通过shmop_delete可以删除 。这就需要你们自己根据项目应用来考虑了

还有就是我这里只是为了简单的读，并没有出现复杂的读写，否则可能会出现进程互斥等意想不到的冲突~如果复杂，那么就可以考虑信号量了~

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

php操作共享内存shmop类及简单使用测试的代码

php实现共享内存进程通信函数（_shm）

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!