Pratique de la coroutine et de la programmation asynchrone de Swoole

Avec le développement continu des applications Internet, la simultanéité élevée est devenue un défi auquel tout développeur doit faire face. Afin de faire face à une concurrence élevée, les étudiants front-end utilisent des technologies telles que l'affichage frontal et les E/S asynchrones, tandis que les étudiants back-end utilisent des coroutines et des technologies de programmation asynchrone. Parmi eux, Swoole est un framework de coroutines dans le langage PHP. Il utilise des coroutines et des idées de programmation asynchrone pour simplifier le développement et le débogage en haute concurrence et offrir aux développeurs une meilleure expérience de développement.

1. Les concepts de coroutines et de programmation asynchrone

La compréhension des coroutines peut être simplement comprise comme des « micro-threads », qui sont des concepts similaires aux threads, mais qui sont différents du mécanisme de commutation de thread. Les coroutines ne sont pas des threads du noyau du système d'exploitation, mais sont commutées au sein du processus utilisateur. L'utilisation de coroutines peut effectuer une attente non bloquante, tout en améliorant l'utilisation du processeur et en réduisant le nombre de changements de contexte.

La programmation asynchrone est une méthode de programmation « basée sur les événements ». Sa principale caractéristique est l'utilisation d'E/S non bloquantes, qui évite le temps d'attente des threads causé par l'attente de blocage des E/S et augmente la concurrence. Dans la programmation asynchrone, lorsqu'un événement est terminé, le programme demandera au thread concerné de poursuivre le traitement, au lieu de laisser le thread se bloquer et attendre. La programmation asynchrone utilise des rappels pour gérer les opérations asynchrones afin de gérer l'alternance entre les coroutines et d'améliorer les capacités de traitement simultané du programme.

2. Pratique de la coroutine et de la programmation asynchrone de Swoole

1. coroutine

La coroutine Swoole simule et implémente le mécanisme de coroutine dans les processus et les threads dans l'environnement du langage PHP. Dans la coroutine de Swoole, vous pouvez utiliser le planificateur de coroutine pour confier le contrôle d'exécution de PHP à la coroutine, évitant ainsi le temps d'attente des threads causé par l'attente de blocage d'E/S et améliorant l'efficacité opérationnelle. Les coroutines réalisent la commutation entre les coroutines à l'aide des fonctions swoole_coroutine_create() et swoole_coroutine_resume(). Dans le même temps, Swoole fournit des fonctions événementielles telles que swoole_event_add(), swoole_event_set(), etc., ce qui simplifie considérablement le modèle de programmation de coroutine.

Ci-dessous, nous comprendrons l'utilisation de la coroutine Swoole étape par étape à travers la pratique du code.

1) Installez l'extension Swoole

Tout d'abord, nous devons installer l'extension Swoole pour réaliser le développement de la coroutine Swoole. L'extension Swoole peut être installée via la commande suivante :

$ pecl install swoole

2) Créer une coroutine

Ensuite, nous devons créer une coroutine et utiliser la fonction swoole_coroutine_resume() pour exécuter la coroutine. Le code spécifique est le suivant :

<?php
function test_coroutine(){
    echo "Start coroutine
";
    swoole_coroutine::sleep(1);
    echo "End coroutine
";
}
swoole_coroutine::create("test_coroutine");
echo "Main func end
";

Nous pouvons voir que la fonction swoole_coroutine_create() est utilisée dans le code pour créer une coroutine et qu'une fonction test_coroutine() est transmise. À ce stade, la coroutine n'a pas encore été exécutée. Après avoir appelé swoole_coroutine_create(), le système soumet la coroutine au planificateur de coroutine et attend son exécution. Ensuite, en appelant la fonction swoole_coroutine_resume(), la fonction test_coroutine() est exécutée et les résultats pertinents sont affichés.

3) Basculer entre les coroutines

Dans la coroutine, nous pouvons également utiliser la fonction swoole_coroutine_yield() pour changer manuellement de coroutines. Le code d'implémentation spécifique est le suivant :

<?php
function test_coroutine(){
    for ($i=0; $i<5; $i++){
        echo "Coroutine $i
";
        swoole_coroutine::yield();
    }
}
$c = swoole_coroutine::create("test_coroutine");
for ($i=0; $i<5; $i++){
    swoole_coroutine::resume($c);
}

Grâce au code ci-dessus, nous avons créé une coroutine et bouclé 5 fois dans la fonction test_coroutine() pour afficher le numéro de coroutine. Utilisez la fonction swoole_coroutine_yield() pour changer manuellement de coroutines afin que plusieurs coroutines puissent être traitées équitablement.

2. Programmation asynchrone

La programmation asynchrone de Swoole est principalement implémentée sur la base de fonctions basées sur des événements telles que Woole_event_add(), swoole_event_set() et swoole_event_wait(). Plus précisément, les fonctions Woole_event_add() et swoole_event_set() sont utilisées pour ajouter des événements d'E/S à la boucle d'événements, tandis que la fonction swoole_event_wait() est utilisée pour démarrer la boucle d'événements.

Ci-dessous, nous comprendrons la pratique de la programmation asynchrone de Swoole étape par étape à travers le code.

1) Installez l'extension Swoole

Tout d'abord, nous devons installer l'extension Swoole pour permettre le développement de la programmation asynchrone Swoole. L'extension Swoole peut être installée via la commande suivante :

$ pecl install swoole

2) Communication TCP asynchrone

Dans Swoole, la communication TCP asynchrone entre les systèmes peut être prise en charge via swoole_client et swoole_server. Dans la communication TCP asynchrone, nous devons utiliser SwooleServer pour démarrer un service TCP et utiliser la fonction swoole_event_add() côté serveur pour ajouter un événement d'E/S au service. L'expéditeur du message utilise swoole_client pour implémenter une communication asynchrone. Le code d'implémentation spécifique est le suivant :

<?php
//异步TCP服务端
$serv = new swoole_server("127.0.0.1", 9501);
$serv->set(array(
    'worker_num' => 4,
    'daemonize' => false,
));

$serv->on('Receive', function ($serv, $fd, $from_id, $data) {
    $serv->send($fd, 'Server: '.$data);
    $serv->close($fd);
});

$serv->start();

<?php
//异步TCP客户端
$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);

$client->on("connect", function($cli) {
    $cli->send("hello world
");
});

$client->on("receive", function($cli, $data){
    echo "Received: ".$data."
";
});

$client->on("error", function($cli){
    echo "Connect failed
";
});

$client->on("close", function($cli){
    echo "Connection closed
";
});

$client->connect('127.0.0.1', 9501);

Grâce au code ci-dessus, nous avons implémenté un exemple de communication TCP asynchrone. Lorsque le client envoie un message, le serveur reçoit le message et renvoie le résultat du traitement.

Résumé :

Cet article explique principalement la pratique de la coroutine Swoole et de la programmation asynchrone. Dans le développement d'applications Internet hautement concurrentes, l'utilisation de programmation asynchrone et de coroutines peut améliorer efficacement les performances du système et améliorer l'efficacité du développement. Le framework Swoole fournit une bonne prise en charge de la programmation coroutine et asynchrone, permettant aux programmeurs de mettre en œuvre facilement un traitement asynchrone et une planification de coroutine efficaces, améliorant ainsi les capacités de traitement simultané du système.

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!