Qu'est-ce que PHP High Concurrency ?

Les problèmes de concurrence sont souvent rencontrés lors du développement et du déploiement d'applications, et lorsque, le trafic devenant plus important, une série de problèmes techniques se posent, il est nécessaire de mettre en place un système de gestion de la concurrence.questionsPar exemple, le délai de réponse de l'interface, la charge élevée de l'unité centrale, les GC fréquents, les blocages, le stockage de données volumineuses, etc. Par exemple : le double 11 de Taobao, des centaines de milliers de requêtes par seconde, le système de commandes quotidiennes de dizaines de millions de commandes, chaque jour des centaines de millions d'activités quotidiennes du système de flux d'informations.

Flux de traitement hautement simultané :

• essais de performance
• Extension du serveur
• système de surveillance
• Gestion des exceptions

I. Tests de performance

Comprendre les performances des systèmes d'essai soumis à des charges élevées, ladécouvertesLes goulets d'étranglement et les problèmes potentiels peuvent être adoptéstest de stressrépondre en chantantessais de performanceLa méthodologie. Voici quelques étapes et outils permettant de simuler un grand nombre d'accès simultanés d'utilisateurs pour l'évaluation des performances du système :

1.Définir les objectifs et les paramètres des tests

• Indicateurs de performanceDéterminez les paramètres de performance que vous souhaitez mesurer, tels que le temps de réponse, le débit (requêtes/seconde), le nombre d'utilisateurs simultanés, l'utilisation des ressources (CPU, mémoire, disque, réseau), etc.
• scénario de testDéfinir les comportements spécifiques des utilisateurs et les modèles d'interaction pour s'assurer que toutes les fonctions clés sont couvertes.

2. Choisir le bon outil de simulation de crise

• JMeterApache JMeter : Apache JMeter peut être utilisé pour tester les performances des ressources statiques et dynamiques, des applications web dynamiques. Il peut être utilisé pour simuler de lourdes charges sur des serveurs, des groupes de serveurs, des réseaux ou des objets afin de tester leur résistance ou d'analyser les performances globales sous différents types de charge.
• GatlingGatling est un autre outil de test de charge très performant qui fournit des rapports détaillés et des scripts faciles à écrire.
• LoadRunnerLoadRunner est un logiciel commercial qui répond aux besoins de tests plus complexes et qui offre des capacités de surveillance et d'analyse étendues.
• Criquet pèlerinLocust est un outil de test de charge léger écrit en Python, facile à étendre et à personnaliser.

3. élaboration de scripts et de scénarios de test

• Rédiger des scripts de test basés sur des modèles de comportement utilisateur définis. Ces scripts doivent simuler diverses actions d'utilisateurs réels, telles que la connexion, la navigation sur des pages, la soumission de formulaires, etc.
• Configurez le nombre d'utilisateurs simultanés et la fréquence des requêtes pour simuler un environnement hautement concurrentiel.

afin deCriquet pèlerinA titre d'exemple :

from locust import HttpUser, between, task


classe WebsiteUser(HttpUser).
    wait_time = between(5, 15)

    def on_start(self).
        self.client.post("/login", {
            "username" : "test_user", "password" : "", "password" : "test_user", {
            "password" : ""
        })

    @task
    def index(self).
        self.client.get("/")
        self.client.get("/static/assets.js")

    @task
    def about(self).
        self.client.get("/about/")

4. Exécuter des tests et contr?ler les performances du système

• Effectuer des tests de résistance dans un environnement de test. Veillez à ce que l'environnement de test soit aussi similaire que possible à l'environnement de production pour obtenir des résultats précis.
• Surveillance en temps réel des performances des applications et des serveurs, y compris le processeur, la mémoire, les entrées-sorties réseau, etc.

5. Analyse des résultats des tests

• Analyser en détail les données recueillies lors des essais afin d'identifier les goulets d'étranglement ou les points de défaillance.
• Examinez les temps de réponse, les taux d'erreur et l'utilisation des ressources du système pour déterminer les points faibles du système.

6. Optimisation et ajustement

• Optimisation des applications et de l'infrastructure sur la base des résultats des tests. Les optimisations possibles comprennent l'optimisation du code, l'optimisation de la base de données, l'augmentation des ressources du serveur, etc.
• Répétez le test pour valider l'optimisation et vous assurer que les modifications apportées améliorent réellement les performances du système.

7. Documentation et tests continus

• Documenter les résultats des tests et les optimisations afin d'établir des références de performance.
• Incorporez des tests de performance dans votre processus d'intégration continue/déploiement continu (CI/CD) pour vous assurer que votre système continue à fonctionner correctement au fil du temps et de l'ajout de nouvelles fonctionnalités.

Vous pouvez ainsi simuler efficacement l'accès des utilisateurs dans des conditions très concurrentielles, en testant et en optimisant votre système pour vous assurer qu'il fonctionne bien dans un environnement opérationnel réel.

II. extension du serveur

Si les tests de performance révèlent que le serveur ne peut pas gérer un grand nombre de requêtes simultanées, envisagez d'étendre le serveur. Vous pouvez augmenter la configuration matérielle du serveur, par exemple en ajoutant des ressources telles que l'unité centrale et la mémoire. L'équilibrage de la charge peut également être réalisé en ajoutant des serveurs supplémentaires pour améliorer les performances.

III. systèmes de contr?le

Après avoir déployé une application, vous devez mettre en place un système de surveillance pour contr?ler les performances du serveur en temps réel. Le système de surveillance peut fournir des données en temps réel sur la charge du serveur, le temps de réponse, le taux d'erreur et d'autres paramètres afin d'aider les développeurs à identifier et à résoudre les problèmes de performance en temps utile.

IV. gestion des exceptions

Dans un environnement hautement concurrentiel, diverses exceptions peuvent se produire fréquemment. Les développeurs doivent écrire du code pour traiter les exceptions en temps voulu. Pour les exceptions qui ne peuvent pas être résolues immédiatement, des mécanismes de tolérance aux pannes, tels que le traitement de la dégradation et le meltdown, peuvent être utilisés pour garantir la stabilité du système. Voici quelques-uns des mécanismes de tolérance aux fautesGestion d'une forte concurrenceLes références méthodologiques :

• Utilisation du cache: La mise en cache est l'un des outils les plus importants pour améliorer les performances. Différents types de caches tels que le cache mémoire, le cache de base de données ou le cache distribué peuvent être utilisés pour stocker des données ou des pages fréquemment utilisées. En réduisant l'accès à la base de données, la charge du serveur peut être considérablement réduite et le temps de réponse peut être amélioré.
• Extension du serveur d'application et de la base de donnéesLa capacité d'une application à gérer une forte concurrence peut être considérablement améliorée en ajoutant des serveurs et en répartissant les demandes à l'aide de l'équilibrage de charge (par exemple, en utilisant HAProxy ou AWS ELB). Optimisez les requêtes de la base de données, utilisez des index plus efficaces ou envisagez d'utiliser une architecture de base de données mieux adaptée aux opérations de lecture/écriture/réduction, telle que la réplication ma?tre-esclave. Dans certains cas, la division des bibliothèques et des tables peut également être une stratégie efficace pour améliorer la puissance de traitement de la base de données.
• traitement asynchroneTraitement asynchrone : Si l'application comporte des opérations qui prennent beaucoup de temps, envisagez d'utiliser le traitement asynchrone pour améliorer la simultanéité. Placez ces opérations dans une file d'attente de messages ou une tache d'arrière-plan pour les traiter, puis renvoyez une réponse rapide à l'utilisateur.

Il y a aussi l'utilisation deVerrouillage de l'exclusion des fichiersChemin :

• mode obstructionnisteSi un processus acquiert un verrou exclusif sur un fichier alors qu'un autre processus occupe le verrou, il attendra que l'autre processus libère le verrou, puis acquerra lui-même le verrou avant de continuer. Exemple.

set(array(
 'reactor_num' => 2, //numéro de thread du réacteur
 'worker_num' => 4 //numéro du processus travailleur
)) ;
$http->on('request', function (swoole_http_request $request, swoole_http_response $response) {
 $uniqid = uniqid('uid-', TRUE) ;
 $redis = new Redis() ;
 $redis->connect('127.0.0.1', 6379);
 $fp = fopen("lock.txt", "w+") ;
 // Mode de blocage (attente), pour obtenir un verrou exclusif (procédure d'écriture)
 if (flock($fp,LOCK_EX)) { // Verrouiller le pointeur courant.
 // Une fois le verrou obtenu, la commande peut être traitée en toute confiance
 $rest_count = intval($redis->get("rest_count")) ;
 $value = "{$rest_count}-{$uniqid}" ;
 if ($rest_count > 0) {
 // faire quelque chose ...
 $rand = rand(100, 1000000) ;
 $sum = 0 ; $sum = 0 ; $sum = 0 ; $sum = 0
 for ($i = 0 ; $i lPush('uniqids', $value) ;
 $redis->decr('rest_count') ;
 }
 // Libère le verrou après le traitement de la commande
 flock($fp, LOCK_UN) ;
 }
 fclose($fp) ; }
}) ;
$http->start() ;

Utilisez le test d'abdominaux :

$ ab -t 20 -c 10 http://192.168.1.104:9510/

• mode non bloquantSi un processus acquiert un verrou exclusif sur un fichier alors qu'un autre processus occupe le verrou, le processus déterminera immédiatement qu'il n'a pas réussi à acquérir le verrou et continuera à s'exécuter. Exemple de code :

set(array(
 'reactor_num' => 2, //numéro de thread du réacteur
 'worker_num' => 4 //numéro du processus travailleur
)) ;
$http->on('request', function (swoole_http_request $request, swoole_http_response $response) {
 $uniqid = uniqid('uid-', TRUE) ;
 $redis = new Redis() ;
 $redis->connect('127.0.0.1', 6379);
 $fp = fopen("lock.txt", "w+") ;
 // Mode non bloquant, si vous ne voulez pas que flock() bloque sur le verrou, mettez LOCK_NB sur le verrou
 if(flock($fp,LOCK_EX | LOCK_NB)) // verrouille le pointeur actuel.
 {
 // Après avoir réussi à acquérir le verrou, traiter la commande en toute confiance
 $rest_count = intval($redis->get("rest_count")) ;
 $value = "{$rest_count}-{$uniqid}" ;
 if($rest_count > 0){
 // faire quelque chose ...
 $rand = rand(100, 1000000) ;
 $sum=0.
 for ($i=0;$ilPush('uniqids', $value) ;
 $redis->decr('rest_count') ;
 }
 // Libère le verrou après le traitement de la commande
 flock($fp,LOCK_UN) ;
 } else {
 // S'il ne parvient pas à acquérir le verrou, allez ici et exécutez-le immédiatement.
 echo "{$uniqid} - system busy, please try again later".PHP_EOL ; } else { // Si l'acquisition du verrou échoue, allez ici immédiatement.
 }
 fclose($fp) ; }
}) ;
$http->start() ;

résumés

Grace à une utilisation raisonnable de la mise en cache, de l'équilibrage des charges, du traitement asynchrone et de l'optimisation de la base de données, il est possible d'améliorer la simultanéité et les performances du système ; grace aux tests de performance, à l'extension des serveurs, aux systèmes de surveillance, au traitement des exceptions et à d'autres procédures opérationnelles, il est possible de s'assurer que le système peut fonctionner de manière stable dans des situations de forte simultanéité.

Contactez nous
Vous n'arrivez pas à lire le tutoriel ? Contactez-nous pour une réponse gratuite ! Aide gratuite pour les sites personnels et les sites de petites entreprises !	Service clientèle WeChat
① Tel : 020-2206-9892
② QQ咨詢：1025174874
(iii) Courriel : info@361sale.com
④ Horaires de travail : du lundi au vendredi, de 9h30 à 18h30, jours fériés.