PHP détaille les moyens d'améliorer les capacités de concurrence

Cet article vous apporte des connaissances pertinentes sur PHP. Il présente principalement les solutions pour améliorer les capacités de concurrence de PHP. L'article le présente en détail à travers un exemple de code, qui a une certaine valeur d'apprentissage de référence pour les études ou le travail de chacun. ensemble, j'espère que cela sera utile à tout le monde.

(Tutoriel recommandé : Tutoriel vidéo PHP)

Cet article a inclus le gîte des notes d'étude de programmation. Couvre PHP, JavaScript, Linux, Golang, MySQL, Redis, les outils open source, etc.

PHP utilisé dans les environnements de production doit être optimisé pour permettre à PHP lui-même de mieux fonctionner. En plus d'écrire du code PHP, vous devez également configurer le réglage de php-fpm et php.ini. Cet article explique le réglage de la configuration de php.ini sous les aspects de mémoire, OPcache, téléchargement, session et sécurité.

Par rapport à d'autres langages compilés, le plus gros inconvénient de PHP est que chaque requête nécessite une analyse de module, et ce qui est réellement exécuté est le processus de travail. Démarrer le processus de travail nécessite plus de ressources. Dans le même temps, chaque requête réanalysera certains codes, ce qui entraînera une analyse répétée.

Pour l'optimisation de PHP, vous pouvez vous concentrer sur cet aspect pour envisager l'optimisation.

Optimisation de la mémoire

Lors de l'exécution de PHP, vous devez vous soucier de la quantité de mémoire utilisée par chaque processus PHP. Le paramètre memory_limit dans php.ini est utilisé pour définir la mémoire système maximale qu'un seul processus PHP utilise. peut utiliser. memory_limit设置用于设定单个 PHP 进程可以使用的系统内存最大值。

这个设置的默认值是 128M，这对于大多数中小型 PHP 应用来说或许合适，不过，如果运行的是微型 PHP 应用，可以降低这个值，以便节省系统资源，反之，如果运行的是内存集中型 PHP 应用，可以增加这个值。这个值的大小由可用的系统内存决定，确定给 PHP 分配多少值是一门艺术，决定给 PHP 分配多少内存，以及能负担起多少个 PHP-FPM 进程时，可以根据以下维度信息进行判断：

• 一共可以分配给 PHP 多少内存？以一个 2G 内存的 VPS 为例，这台设备中可能还运行了其他进程，如 MySQL、Nginx 等，那么留 512M 给 PHP 是合适的。
• 每个 PHP 进程平均耗费多少内存？这个要监控进程的内存使用量，可以使用命令行命令top，也可以在 PHP 脚本中调用 memory_get_peak_usage()
La valeur par défaut de ce paramètre est de 128 Mo, ce qui peut convenir à la plupart des applications PHP de petite et moyenne taille. Cependant, si vous exécutez une application micro-PHP, vous pouvez réduire cette valeur pour économiser les ressources système. , si vous exécutez une mémoire Pour les applications PHP centralisées, cette valeur peut être augmentée. La taille de cette valeur est déterminée par la mémoire système disponible. Déterminer la quantité de valeur à allouer à PHP est un art. Lorsqu'il s'agit de décider de la quantité de mémoire à allouer à PHP et du nombre de processus PHP-FPM qu'il peut se permettre, cela peut être jugé en fonction. sur les informations dimensionnelles suivantes :

Quelle quantité de mémoire peut être allouée à PHP ? Prenons l'exemple d'un VPS avec 2 Go de mémoire. Cet appareil peut également exécuter d'autres processus, tels que MySQL, Nginx, etc., il convient donc de laisser 512 Mo pour PHP.

Combien de mémoire chaque processus PHP consomme-t-il en moyenne ? Pour surveiller l'utilisation de la mémoire du processus, vous pouvez utiliser la commande de ligne de commande top, ou vous pouvez appeler la fonction memory_get_peak_usage() dans un script PHP, quelle que soit la méthode. est utilisé, exécutez le même script plusieurs fois et faites la moyenne de la consommation de mémoire.

Combien de processus PHP-FPM pouvez-vous vous permettre ? Supposons que j'alloue 512 Mo de mémoire à PHP et que chaque processus PHP consomme en moyenne 15 Mo de mémoire, je peux alors me permettre 34 processus PHP-FPM.


Les ressources système sont-elles suffisantes ? Enfin, vous devez confirmer qu'il existe suffisamment de ressources système pour exécuter l'application PHP et gérer le trafic attendu. Pour des informations de configuration PHP spécifiques, veuillez vous référer au fichier de configuration php-fpm.config.

 ; Délai pendant lequel les processus enfants attendent une réaction aux signaux du maître.
 ; Unités disponibles : s(secondes), m(inutes), h(ours) ou d(ays)
 ;
 ; Valeur par défaut : 0
 ; process_control_timeout = 0

 ; Le nombre maximum de processus que FPM va bifurquer 

 ; Utilisez-le. avec prudence.
; Remarque : Une valeur de 0 indique aucune limite
 ; Valeur par défaut : 0
 ; process.max = 128

 ; Spécifiez la priorité nice(2) à appliquer au processus maître (uniquement si elle est définie)
 ; La valeur peut varier de -19 (priorité la plus élevée) à 20 (priorité la plus basse)

 ; Remarque : - Cela ne fonctionnera que si le processus maître FPM est lancé en tant que root

- Le processus du pool héritera de la priorité du processus maître
 ; spécifié autrement
 ; Valeur par défaut : non set

 ; process.priority = -19

 ; Envoyer FPM en arrière-plan ; Définir sur "non" pour conserver FPM au premier plan pour le débogage.

 ;

php-fpm a trois modes de fonctionnement, à savoir un nombre fixe de processus, un nombre de processus à la demande et un nombre de processus entièrement dynamique.
• Le nombre de processus à la demande, quelques processus sont initialisés par défaut. Si la quantité d'entrée est trop importante, certains nouveaux processus seront créés dynamiquement. Une fois la demande terminée, les processus nouvellement créés seront détruits.
• Fixez le nombre de processus. Par défaut, quelques processus sont fixes. Si le nombre de processus n'est pas suffisant, les nouvelles demandes attendront et ne seront traitées que lorsque les autres processus auront terminé leur traitement.

Le nombre de processus complètement dynamiques signifie qu'il est entièrement contrôlé par le nombre de demandes. Un processus est créé pour chaque demande et est détruit après traitement.

Activer l'accélération des performances de Zend OPcache

🎜Après avoir déterminé la quantité de mémoire à allouer, vous pouvez configurer l'extension Zend OPcache de PHP. OPcache analyse principalement certains codes en bytecode, il n'est donc pas nécessaire d'analyser et de compiler à plusieurs reprises cette partie du code dans les requêtes ultérieures. Réduire le processus de compilation et d'analyse peut également améliorer la vitesse de traitement de PHP. 🎜

PHP5.5.0+ a cette extension intégrée. Voici quelques informations de configuration nécessaires :

opcache.memory_consumption = 64 : La mémoire allouée pour le cache d'opcode (l'unité est Mo), la mémoire allouée. Le montant doit pouvoir sauvegarder les opcodes compilés par tous les scripts PHP de l'application. Cette valeur peut être définie sur différentes tailles en fonction de la taille de l'application. opcache.memory_consumption = 64：为操作码缓存分配的内存（单位是MB），分配的内存量应该可以保存应用中所有 PHP 脚本编译得到的操作码，这个值根据应用的体量可以设置成不同大小的值。

opcache.interned_strings_buffer = 16：用来存储驻留字符串的内存量（单位是MB），什么是驻留字符串呢？PHP 解释器在背后会找到相同字符串的多个实例，把这个字符串保存在内存中，如果再次使用相同的字符串，PHP 解释器会使用指针，这么做的目的是节省内存。默认情况下，PHP 驻留字符串会隔离在各个 PHP 进程中，这个设置能让 PHP-FPM 进程池把所有进程驻留字符串存储到共享的缓冲区中，以便在 PHP-FPM 进程池中的多个进程之间引用驻留字符串，这样能节省更多内存。

opcache.max_accelerated_files = 4000：操作码缓存中最多能存储多少个 PHP 脚本，这个值的区间是 2000 到 100000 之间，这个值一定要比 PHP 应用中的文件数大。

opcache.validate_timestamps = 1：这个设置的值为1时，经过一段时间后 PHP 会检查 PHP 脚本的内容是否有变化，检查的时间间隔由opcache.revalidate_freq设置指定。如果这个设置的值为0，PHP 不会检查 PHP 脚本的内容是否有变化，我们必须自己动手清除缓存的操作码。建议在开发环境中设置为1，生产环境中设置为0。

opcache.revalidate_freq = 0：设置多久（单位是秒）检查一次 PHP 脚本内容是否有变化。设置为0秒的含义是仅当opcache.validate_timestamps设置为1时，才会在每次请求时都重新验证 PHP 文件，因此，在开发环境中每次都会重新验证 PHP 文件，在生产环境中则不验证。

opcache.fast_shutdown = 1：这么设置能让操作码使用更快的停机步骤，把对象析构和内存释放交给 Zend Engine 的内存管理器完成。

文件上传

如果你的应用允许上传文件，最好设置最大能上传的文件大小。除此之外，最好还要设置最多能同时上传多少个文件：

file_uploads = 1
upload_max_filesize = 10M
max_file_uploads = 3

默认情况下，PHP 允许在单次请求中上传 20 个文件，上传的文件最大为 2MB，这里我设置为单次请求最多只能上传 3 个文件，每个文件最大为 10MB，这个值不要设置太大，否则会出现超时。

注：如果非要上传大文件，Web 服务器的配置也要做相应调整。除了在 php.ini 中设置之外，还要调整 Nginx 虚拟主机配置中的 client_max_body_size 设置。

此外，如果是上传特大文件，我建议使用Webuploader专门的上传组件，前端对大文件进行切片，后端php对分片数据进行合并还原文件。有关WebUploader应用请参考本站文章：功能强大的文件上传组件-WebUploader。

执行时间

max_execution_time 用于设置单个 PHP 进程在终止之前最长可运行时间。这个设置默认是 30 秒，建议将其设置为 5 秒：

max_execution_time = 5

在 PHP 脚本中可以调用set_limit_time()

opcache.interned_strings_buffer = 16 : La quantité de mémoire utilisée pour stocker les chaînes résidentes (l'unité est Mo). Qu'est-ce qu'une chaîne résidente ? En coulisses, l'interpréteur PHP trouvera plusieurs instances de la même chaîne et enregistrera la chaîne en mémoire. Si la même chaîne est utilisée à nouveau, l'interpréteur PHP utilisera un pointeur. Le but est d'économiser de la mémoire. Par défaut, les chaînes résidentes PHP seront isolées dans chaque processus PHP. Ce paramètre permet au pool de processus PHP-FPM de stocker toutes les chaînes résidentes du processus dans un tampon partagé afin qu'elles puissent être traitées dans le pool de processus PHP-FPM. sont référencés entre plusieurs processus, ce qui économise plus de mémoire.

opcache.max_accelerated_files = 4000 : Le nombre maximum de scripts PHP pouvant être stockés dans le cache opcode. La plage de cette valeur est comprise entre 2000 et 100000. Cette valeur doit être supérieure au nombre de. fichiers dans l'application PHP.

opcache.validate_timestamps = 1 : Lorsque la valeur de ce paramètre est 1, PHP vérifiera si le contenu du script PHP a changé après un certain temps. L'intervalle de vérification est spécifié par l'opcache. Paramètre .revalidate_freq. Si la valeur de ce paramètre est 0, PHP ne vérifiera pas si le contenu du script PHP a changé et nous devons nous-mêmes effacer les opcodes mis en cache. Il est recommandé de le définir sur 1 dans l'environnement de développement et sur 0 dans l'environnement de production.

opcache.revalidate_freq = 0 : Définissez la fréquence (en secondes) pour vérifier si le contenu du script PHP a changé. La signification de la valeur 0 seconde est que le fichier PHP sera revalidé à chaque requête uniquement si opcache.validate_timestamps est défini sur 1, donc dans l'environnement de développement, le fichier PHP sera revalidé à chaque fois, mais pas dans l'environnement de développement. vérification de l'environnement de production.

opcache.fast_shutdown = 1 : Ce paramètre permet à l'opcode d'utiliser une étape d'arrêt plus rapide, laissant la destruction des objets et la libération de mémoire au gestionnaire de mémoire de Zend Engine.

Téléchargement de fichiers

Si votre application autorise le téléchargement de fichiers, il est préférable de définir la taille maximale du fichier pouvant être téléchargé. De plus, il est préférable de définir le nombre maximum de fichiers pouvant être téléchargés en même temps :

session.save_handler = "memcached"
session.save_path = "服务地址:端口号"

Par défaut, PHP permet de télécharger 20 fichiers en une seule requête, et la taille maximale du fichier téléchargé est de 2 Mo. Ici, je. définissez-le sur single. La demande ne peut télécharger que jusqu'à 3 fichiers, et chaque fichier peut atteindre 10 Mo. Ne définissez pas cette valeur trop grande, sinon un délai d'attente se produira.

Remarque : Si vous devez télécharger des fichiers volumineux, la configuration du serveur Web doit être ajustée en conséquence. En plus de le définir dans php.ini, ajustez le paramètre client_max_body_size dans la configuration de l'hôte virtuel Nginx. 🎜🎜De plus, si vous téléchargez des fichiers très volumineux, je vous recommande d'utiliser le composant de téléchargement spécialisé de Webuploader. Le frontal découpe les fichiers volumineux et le back-end PHP fusionne les données fragmentées pour restaurer les fichiers. Pour plus d'informations sur l'application WebUploader, veuillez vous référer à l'article sur ce site : Puissant composant de téléchargement de fichiers-WebUploader. 🎜🎜Durée d'exécution🎜🎜max_execution_time est utilisé pour définir la durée maximale pendant laquelle un seul processus PHP peut s'exécuter avant d'être terminé. Ce paramètre est par défaut de 30 secondes, et il est recommandé de le définir sur 5 secondes : 🎜

output_buffering = 4096
implicit_flush = false

🎜Vous pouvez appeler la fonction set_limit_time() dans un script PHP pour remplacer ce paramètre. 🎜🎜Supposons que nous souhaitions générer un rapport et transformer les résultats dans un fichier PDF. Cette tâche peut prendre 10 minutes, et nous ne voulons certainement pas faire attendre la requête PHP 10 minutes. Nous devrions écrire un PHP séparé. et laissez-le attendre 10 minutes. S'exécutant dans un processus en arrière-plan, l'application Web peut générer un processus en arrière-plan distinct en quelques millisecondes seulement, puis renvoyer une réponse HTTP. 🎜🎜En fait, lorsque nous exécutons des tâches qui prennent beaucoup de temps, nous utilisons généralement des processus en arrière-plan. Par exemple, nous pouvons utiliser l'extension swoole de PHP pour générer des rapports et envoyer des e-mails par lots, ce qui prend beaucoup de temps. 🎜🎜Traitement des sessions🎜🎜La situation par défaut de PHP est de stocker les informations générées par la session sur le disque, telles que les informations dites de session. Lors de la création et de la lecture d'une session, les opérations d'E/S sont effectuées sur le disque. La lecture et l'écriture du disque sont en réalité une opération relativement longue. Et la session n'est pas pratique pour traiter le mécanisme de session des applications distribuées. Il est recommandé de le placer dans un service en mémoire tel que Redis et Memcached, qui a des vitesses de lecture et d'écriture rapides et peut être traité par un mécanisme de session distribuée. 🎜🎜L'exemple suivant stocke des informations telles que la session dans la mémoire Memcached. 🎜

open_basedir = /data/www

🎜Buffer🎜🎜Le réseau serait plus efficace si plus de données étaient envoyées en moins de morceaux, plutôt que moins de données en plusieurs morceaux, c'est-à-dire en moins de morceaux. La fourniture de contenu au navigateur du visiteur dans un fragment peut réduire le nombre total. de requêtes HTTP. 🎜🎜Par conséquent, nous devons laisser PHP tamponner la sortie. Par défaut, PHP a activé la fonction de mise en mémoire tampon de sortie. PHP met en mémoire tampon 4096 octets de sortie avant d'envoyer le contenu au serveur Web : 🎜

output_buffering = 4096
implicit_flush = false

如果想要修改输出缓冲区的大小，确保使用的值是4（32位系统）或8（64位系统）的倍数。

安全设置

open_basedir：使用open_basedir选项能够控制PHP脚本只能访问指定的目录，这样能够避免PHP脚本访问不应该访问的文件，一定程度上限制了phpshell的危害。我们一般可以设置为只能访问网站目录：

open_basedir = /data/www

disable_functions：一般我们要禁止系统函数和禁止任何文件和目录的操作，如：

disable_functions = '.....'

expose_php = Off：将此项设置为false即不会再header头输出PHP版本信息。

display_errors = Off：生产环境中，我们应该禁止错误提示，如果是本地开发环境，可以设置为On。

log_errors = On：建议在关闭display_errors后能够把错误信息记录下来，便于查找服务器运行的原因。

error_log：设置PHP错误日志存放的目录。

（推荐教程：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!