Une introduction dans les boucles d'événements en php

Boucle d'événement PHP: une arme pour la programmation asynchrone

Points de base

• La boucle d'événements PHP est une structure de programmation utilisée pour attendre des événements ou des messages dans un planificateur, en particulier pour la gestion des opérations asynchrones.
• La programmation PHP traditionnelle est synchrone, effectuant une opération à la fois et en attendant que chaque opération se termine avant de continuer avec l'opération suivante. Bien que la boucle d'événement autorise la programmation asynchrone, où une opération peut être démarrée, puis suspendue jusqu'à ce que le résultat soit prêt, d'autres opérations peuvent être effectuées pendant cette période.
• Les bibliothèques telles que ReactPHP ou AMP fournissent les interfaces et classes nécessaires pour créer et gérer des boucles d'événements PHP, permettant une meilleure utilisation des ressources et des temps de réponse plus courts, en particulier dans les applications qui doivent gérer un grand nombre de connexions simultanées.
• Bien que les boucles d'événements puissent offrir des avantages de performance significatifs, ils peuvent également augmenter la complexité de l'application, nécessiter différents styles de programmation et rendre le code plus difficile à comprendre et à déboguer. Toutes les tâches ne conviennent pas au traitement asynchrone, et certaines tâches peuvent être plus difficiles à mettre en œuvre dans des boucles d'événements.

Les développeurs PHP attendent toujours quelque chose. Parfois, nous attendons une demande de services distants. Parfois, nous attendons que la base de données retourne les lignes des requêtes complexes. Ne serait-ce pas génial si nous pouvions faire d'autres opérations pendant toutes les périodes d'attente?

Si vous avez écrit du code JS, vous connaissez peut-être les rappels et les événements DOM. Bien que nous ayons également des rappels en PHP, ils ne fonctionnent pas exactement de la même manière. C'est grâce à une fonctionnalité appelée Event Loop.

Nous comprendrons comment fonctionnent les boucles d'événements et comment utiliser les boucles d'événements en php.

Nous verrons des bibliothèques PHP intéressantes. Certaines personnes croient que ces bibliothèques ne sont pas assez stables pour être utilisées dans les environnements de production. Certaines personnes pensent que les exemples fournis ici sont "de préférence mis en œuvre dans une langue plus mature". Il existe de nombreuses bonnes raisons d'essayer ces méthodes. Il existe également de bonnes raisons d'éviter ces méthodes dans les environnements de production. Le but de cet article est de mettre en évidence les possibilités en PHP.

lieu d'attente

Pour comprendre les boucles d'événements, voyons comment ils fonctionnent dans le navigateur. Jetez un œil à cet exemple:

function fitToScreen(selector) {
    var element = document.querySelector(selector);

    var width = element.offsetWidth;
    var height = element.offsetHeight;

    var top = "-" + (height / 2) + "px";
    var left = "-" + (width / 2) + "px";

    var ratio = getRatio(width, height);

    setStyles(element, {
        "position": "absolute",
        "left": "50%",
        "top": "50%",
        "margin": top + " 0 0 " + left,
        "transform": "scale(" + ratio + ", " + ratio + ")"
    });
}

function getRatio(width, height) {
    return Math.min(
        document.body.offsetWidth / width,
        document.body.offsetHeight / height
    );
}

function setStyles(element, styles) {
    for (var key in styles) {
        if (element.style.hasOwnProperty(key)) {
            element.style[key] = styles[key];
        }
    }
}

fitToScreen(".welcome-screen");

Ce code ne nécessite pas de bibliothèques supplémentaires. Il fonctionne dans n'importe quel navigateur qui prend en charge la conversion de zoom CSS. La dernière version Chrome est suffisante. Assurez-vous simplement que le sélecteur CSS correspond aux éléments du document.

Ces fonctions reçoivent un sélecteur CSS et central et à l'échelle des éléments pour s'adapter à l'écran. Que se passe-t-il si nous lançons une erreur dans la boucle pour? Nous verrons quelque chose comme ça ...

Nous appelons cette trace de pile de liste de fonctions. C'est à quoi ressemble l'intérieur de la pile utilisée par le navigateur. Ils traiteront ce code en étapes ...

C'est comme la façon dont PHP utilise la pile pour stocker le contexte. Le navigateur va plus loin et fournit des webapi pour des contenus tels que les événements DOM et les rappels AJAX. Dans son état naturel, JavaScript est asynchrone comme PHP. C'est-à-dire: bien que les deux semblent être en mesure d'effectuer de nombreuses opérations en même temps, ils sont tous les deux unique. Ils ne peuvent faire qu'une seule chose à la fois.

En utilisant des webapis de navigateur tels que Settimeout et AddEventListener, nous pouvons décharger le travail parallèle à différents threads. Lorsque ces événements se produisent, le navigateur ajoute le rappel à la file d'attente de rappel. Lorsque la pile est vide la prochaine fois, le navigateur ramasse les rappels dans la file d'attente de rappel et les exécute.

Ce processus de nettoyage de la pile, puis de rappeler la file d'attente est la boucle d'événement.

Vie sans boucle d'événement

Dans JS, nous pouvons exécuter le code suivant:

function fitToScreen(selector) {
    var element = document.querySelector(selector);

    var width = element.offsetWidth;
    var height = element.offsetHeight;

    var top = "-" + (height / 2) + "px";
    var left = "-" + (width / 2) + "px";

    var ratio = getRatio(width, height);

    setStyles(element, {
        "position": "absolute",
        "left": "50%",
        "top": "50%",
        "margin": top + " 0 0 " + left,
        "transform": "scale(" + ratio + ", " + ratio + ")"
    });
}

function getRatio(width, height) {
    return Math.min(
        document.body.offsetWidth / width,
        document.body.offsetHeight / height
    );
}

function setStyles(element, styles) {
    for (var key in styles) {
        if (element.style.hasOwnProperty(key)) {
            element.style[key] = styles[key];
        }
    }
}

fitToScreen(".welcome-screen");

Lorsque nous exécutons ce code, nous voyons en dehors du délai d'expiration de la console, puis à l'intérieur du délai d'attente. La fonction Settimeout fait partie de la webapi fournie par le navigateur. Après 1 milliseconde s'est écoulé, ils ajoutent le rappel à la file d'attente de rappel.

La deuxième console.log est effectuée avant le début de la console.log de l'intérieur du settimeout. Nous n'avons rien de tel que settimeout en php standard, mais si nous devons essayer de le simuler:

setTimeout(function() {
    console.log("inside the timeout");
}, 1);

console.log("outside the timeout");

Lorsque nous l'exécutons, nous voyons à l'intérieur du délai d'expiration, puis en dehors du délai d'attente. En effet, nous devons utiliser une boucle infinie dans la fonction setTimeout pour exécuter le rappel après un retard.

Il peut être tentant de se déplacer lors de la boucle en dehors de Settimeout et d'inclure tout le code. Cela peut rendre notre code moins bloqué, mais à un moment donné, nous serons toujours bloqués par cette boucle. À un moment donné, nous verrons que nous ne pouvons faire qu'une seule chose dans un fil à la fois.

Bien qu'il n'y ait rien de tel que Settimeout en PHP standard, il existe des moyens obscurs d'implémenter le code non bloquant en parallèle avec la boucle d'événement. Nous pouvons utiliser des fonctions telles que Stream_Select pour créer un réseau non bloquant iOS. Nous pouvons utiliser des extensions C comme l'EIO pour créer un code système de fichiers non bloquant. Jetons un coup d'œil à la bibliothèque construite sur ces méthodes obscures ...

ICTICLE

ICTICLE est une bibliothèque de composants qui prend en compte les boucles d'événements. Regardons un exemple simple:

function setTimeout(callable $callback, $delay) {
    $now = microtime(true);

    while (true) {
        if (microtime(true) - $now > $delay) {
            $callback();
            return;
        }
    }
}

setTimeout(function() {
    print "inside the timeout";
}, 1);

print "outside the timeout";

Ceci utilise ICTICLEIO / ICTICLE Version 0.8.0

La mise en œuvre de la boucle d'événements de Icicle est excellente. Il a également de nombreuses autres fonctionnalités impressionnantes; comme une promesse, une prise et une implémentation du serveur.

ICTICLE utilise également des générateurs comme coroutines. Les générateurs et les coroutines sont un sujet différent, mais le code qu'ils permettent est magnifique:

use Icicle\Loop;

Loop\timer(0.1, function() {
    print "inside timer";
});

print "outside timer";

Loop\run();

Ceci utilise le générateur ICILEIO / DNS Version 0.5.0 pour faciliter le code asynchrone de l'écriture similaire au code synchrone. Lorsqu'ils sont combinés avec des promesses et des boucles d'événements, ils produisent un excellent code non bloquant comme celui-ci!

reactphp

reactphp a une implémentation de boucle d'événement similaire, mais sans tout le contenu de générateur intéressant:

function fitToScreen(selector) {
    var element = document.querySelector(selector);

    var width = element.offsetWidth;
    var height = element.offsetHeight;

    var top = "-" + (height / 2) + "px";
    var left = "-" + (width / 2) + "px";

    var ratio = getRatio(width, height);

    setStyles(element, {
        "position": "absolute",
        "left": "50%",
        "top": "50%",
        "margin": top + " 0 0 " + left,
        "transform": "scale(" + ratio + ", " + ratio + ")"
    });
}

function getRatio(width, height) {
    return Math.min(
        document.body.offsetWidth / width,
        document.body.offsetHeight / height
    );
}

function setStyles(element, styles) {
    for (var key in styles) {
        if (element.style.hasOwnProperty(key)) {
            element.style[key] = styles[key];
        }
    }
}

fitToScreen(".welcome-screen");

Ceci utilise React / Event-Boop version 0.4.1

reactphp est plus mature que Icicle et a une plus large gamme de composants. Icicle a encore un long chemin à parcourir pour rivaliser avec toutes les fonctionnalités offertes par Reactphp. Cependant, les développeurs font de bons progrès!

Conclusion

Il est difficile de se débarrasser de l'état d'esprit unique que nous avons appris à avoir. Si nous avons accès à des API et à des boucles d'événements non bloquantes, nous ne savons pas combien de code nous pouvons écrire.

La communauté PHP doit comprendre cette architecture. Nous devons apprendre et expérimenter avec une exécution asynchrone et parallèle. Nous devons voler ces concepts et les meilleures pratiques d'autres langues qui ont des boucles d'événements pendant des années jusqu'à ce que «comment utiliser le plus de ressources système?» Devient une question facile à répondre avec PHP.

Restez à l'écoute pour une mise en œuvre plus pratique du prochain glaçon!

FAQ de boucle d'événement PHP

Quel est le rôle des boucles d'événements dans PHP?

Les boucles d'événements en PHP sont des structures de programmation utilisées pour attendre des événements ou des messages dans un planificateur. Il fonctionne en suivant chaque événement actif en réponse aux stimuli externes et en les planifiant lorsque ils sont terminés. Ceci est particulièrement utile dans PHP pour gérer les opérations asynchrones, où vous souhaitez démarrer l'opération, puis continuer à traiter sans attendre l'opération.

Quelle est la différence entre les boucles d'événements et la programmation PHP traditionnelle?

La programmation PHP traditionnelle est synchrone, ce qui signifie qu'il effectue une opération à la fois, dans l'ordre où il a été écrit et doit attendre que chaque opération se termine avant de continuer avec l'opération suivante. D'un autre côté, les boucles d'événements permettent une programmation asynchrone. Cela signifie que l'action peut être démarrée, puis la mettre en attente jusqu'à ce que le résultat soit prêt, pendant lequel d'autres actions peuvent être effectuées.

Comment implémenter des boucles d'événements dans mon application PHP?

La mise en œuvre de boucles d'événements dans votre application PHP implique l'utilisation de bibliothèques qui fournissent ces fonctionnalités, telles que ReactPHP ou AMP. Ces bibliothèques fournissent les interfaces et classes nécessaires pour créer et gérer des boucles d'événements. Vous pouvez ensuite utiliser cette boucle d'événement pour gérer les tâches asynchrones de votre application.

Quels sont les avantages de l'utilisation de boucles d'événements PHP?

L'utilisation de boucles d'événements en PHP peut considérablement améliorer les performances et la réactivité des applications. Il vous permet de traiter plusieurs tâches simultanément, plutôt que séquentiellement, ce qui peut conduire à une meilleure utilisation des ressources et des temps de réponse plus courts. Ceci est particulièrement avantageux dans les applications qui nécessitent la gestion d'un grand nombre de connexions simultanées, telles que les serveurs de chat ou les flux de données en temps réel.

Quels sont les inconvénients de l'utilisation de boucles d'événements PHP?

Bien que les boucles d'événements puissent offrir des avantages de performance significatifs, ils peuvent également augmenter la complexité de l'application. Ils nécessitent différents styles de programmation et peuvent rendre le code plus difficile à comprendre et à déboguer. De plus, toutes les tâches ne conviennent pas au traitement asynchrone, et certaines tâches peuvent être plus difficiles à mettre en œuvre dans des boucles d'événements.

Puis-je utiliser des boucles d'événements avec des frameworks PHP comme Laravel ou Symfony?

Oui, les boucles d'événements peuvent être utilisées avec des cadres PHP comme Laravel ou Symfony, bien que cela puisse nécessiter une configuration supplémentaire. Les deux cadres sont conçus pour fonctionner avec le code PHP synchrone, mais ils peuvent être adaptés pour fonctionner avec des boucles d'événements pour gérer les tâches asynchrones.

Comment gérer les erreurs dans la boucle d'événement?

La gestion des erreurs dans les boucles d'événement peut être plus compliquée que la gestion des erreurs dans le code PHP synchronisé. Étant donné que la tâche est exécutée de manière asynchrone, l'erreur ne peut pas être attrapée immédiatement. Au lieu de cela, vous devez généralement fournir une fonction de rappel qui sera appelée lorsqu'une erreur se produit.

Puis-je utiliser des boucles d'événements dans des scripts CLI PHP?

Oui, vous pouvez utiliser des boucles d'événements dans des scripts PHP CLI (interface de ligne de commande). En fait, il s'agit d'un cas d'utilisation courant pour les boucles d'événements, car les scripts CLI nécessitent souvent que plusieurs tâches soient exécutées simultanément.

Comment fonctionne la boucle d'événements avec la collection Garbage de PHP?

La collection de déchets de PHP fonctionne indépendamment des boucles d'événements. Cependant, comme la boucle d'événement conserve des références à toutes les tâches actives, ces tâches ne seront collectées que après l'achèvement. Cela signifie que vous devez faire attention pour éviter les fuites de mémoire dans le code de boucle d'événement.

Puis-je utiliser des boucles d'événements avec le serveur intégré de PHP?

Oui, vous pouvez utiliser des boucles d'événements avec le serveur intégré de PHP. Cependant, n'oubliez pas qu'un serveur intégré n'est pas conçu à des fins de production et peut ne pas fournir le même niveau de performances ou de fiabilité qu'un serveur Web dédié.

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!