Swoole en action : Comment utiliser les coroutines pour améliorer les performances des applications

Swoole en action : Comment utiliser les coroutines pour améliorer les performances des applications

À mesure que les applications Internet deviennent de plus en plus complexes, les performances sont devenues un problème de plus en plus important. En tant que cadre de communication réseau hautes performances pour les coroutines, Swoole peut très bien résoudre ce problème. Cet article présentera quelques concepts de base des coroutines Swoole et prendra des exemples pour montrer comment utiliser les coroutines pour améliorer les performances des applications.

1. Qu'est-ce qu'une coroutine ? La coroutine est un thread léger qui peut réaliser une collaboration multitâche sur un seul thread et peut basculer librement entre les coroutines. Dans Swoole, les coroutines peuvent simplifier la complexité de la programmation asynchrone. Grâce aux coroutines, nous pouvons écrire du code asynchrone tout comme l'écriture de code synchrone, améliorant ainsi la lisibilité et la maintenabilité du code.

2. Utilisation de base de la coroutine

Dans Swoole, la coroutine est créée via la fonction swoole_coroutine_create Le code est le suivant :

//创建协程
$cid = swoole_coroutine_create(function(){
    echo "Hello Coroutine
";
});

//若主线程不阻塞，则协程无法执行

Après avoir créé la coroutine, vous devez utiliser la fonction swoole_event_wait pour attendre l'exécution de la coroutine. coroutine. Le code est le suivant :

//创建协程
$cid = swoole_coroutine_create(function(){
    echo "Hello Coroutine
";
});

//等待协程执行
swoole_event_wait();

Le code ci-dessus peut afficher "Bonjour Coroutine", indiquant que la coroutine a été exécutée avec succès.

Dans la coroutine, vous pouvez également utiliser la fonction swoole_coroutine_yield pour abandonner la coroutine actuelle et laisser d'autres coroutines s'exécuter :

$cid1 = swoole_coroutine_create(function(){
    echo "Coroutine 1
";
    swoole_coroutine_yield();
    echo "Coroutine 1 resume
";
});

$cid2 = swoole_coroutine_create(function(){
    echo "Coroutine 2
";
    swoole_coroutine_yield();
    echo "Coroutine 2 resume
";
});

swoole_coroutine_resume($cid1);
swoole_coroutine_resume($cid2);
swoole_event_wait();

Dans le code ci-dessus, deux coroutines sont d'abord créées, puis la fonction swoole_coroutine_resume. est utilisé pour fusionner les deux coroutines. Chaque coroutine reprend l'exécution respectivement Puisque la fonction swoole_coroutine_yield est appelée dans la coroutine, la coroutine affichera respectivement "Coroutine 1" et "Coroutine 2", puis toutes deux suspendront l'exécution et abandonneront le CPU. Enfin, une fois que la coroutine a terminé un cycle, récupérez le processeur et affichez respectivement "Coroutine 1 CV" et "Coroutine 2 CV".

3. Compétences communes des coroutines

Gestion des tâches simultanées

1. Dans Swoole, la fonction swoole_coroutine_wait peut être utilisée pour implémenter l'exécution simultanée et la synchronisation de plusieurs coroutines. Le code est le suivant :

$tasks = [
    "task1" => function () {
        sleep(1);
        return "Task 1 Done
";
    },
    "task2" => function () {
        sleep(1);
        return "Task 2 Done
";
    },
];

$results = [];

foreach ($tasks as $name => $task) {
    $cid = swoole_coroutine_create(function () use ($name, $task, &$results) {
        $result = $task();
        $results[$name] = $result;
    });
    swoole_coroutine_resume($cid);
}

swoole_coroutine_wait();
print_r($results);

Dans le code ci-dessus. , définissez-le d'abord. Deux tâches sont créées. Sleep(1) est ajouté à la fonction d'exécution de tâche pour simuler le temps d'exécution de la tâche. Ensuite, une boucle foreach est utilisée pour créer deux coroutines, les résultats de l'exécution sont enregistrés dans le tableau $results et. enfin la fonction swoole_coroutine_wait est appelée pour attendre La coroutine est terminée et le résultat de l'exécution est obtenu.

Traitement des tâches IO

2. Dans Swoole, la fonction swoole_coroutine_system_exec peut être utilisée pour exécuter des commandes système de manière asynchrone et renvoyer les résultats. Le code est le suivant :

function async_exec($cmd)
{
    $fp = popen($cmd, "r");
    if ($fp) {
        while (!feof($fp)) {
            yield fread($fp, 8192);
        }
        pclose($fp);
    }
}

$s = microtime(true);
$coroutine = async_exec('ls /');
foreach ($coroutine as $stdout) {
    echo $stdout;
}
$e = microtime(true);
echo "Time used: " . ($e - $s) . "s
";

Dans le code ci-dessus, la fonction async_exec est utilisée pour exécuter. Les commandes système sont asynchrones et le rendement est utilisé pour lire étape par étape. Obtenez le résultat de sortie et enfin affichez l'heure à laquelle la commande a été exécutée.

Technologie de pool de connexions

3. Dans Swoole, la fonction de pool de connexions à la base de données est intégrée, ce qui peut simplifier les opérations de base de données et améliorer l'efficacité de l'exécution simultanée via le client coroutine swoole_mysql. Le code est le suivant :

$pool = new SwooleCoroutineChannel(10);
for ($i = 0; $i < 10; $i++) {
    $conn = new SwooleCoroutineMySQL();
    $conn->connect([
        'host' => '127.0.0.1',
        'user' => 'root',
        'password' => '123456',
        'database' => 'test',
    ]);
    $pool->push($conn);
}

go(function () use ($pool) {
    $conn = $pool->pop();
    $result = $conn->query('select * from users');
    //...
    $pool->push($conn);
});

Dans le code ci-dessus, créez d'abord un pool de connexions, utilisez une boucle for pour créer 10 connexions MySQL et rejoignez le pool de connexions, puis utilisez la fonction go pour créer une coroutine et supprimez une connexion du pool de connexions pour effectuer des opérations de requête de base de données, et enfin remettre la connexion dans le pool de connexions. L'avantage du pool de connexions est qu'il peut réduire la surcharge provoquée par la création et la destruction de connexions et améliorer les performances des opérations de base de données.

4. Exemples d'utilisation de Swoole pour améliorer les performances des applications de microservices

Swoole possède de très fortes capacités de programmation de coroutines et peut aider les développeurs à écrire efficacement des applications côté serveur hautes performances et à haute concurrence. Ce qui suit prend comme exemple une application de microservice pour montrer comment utiliser la technologie coroutine de Swoole pour améliorer les performances des applications.

Programme de simulation de microservices

1. Tout d'abord, nous créons un programme de microservice simple avec le code suivant :

<?php
//微服务1
function service1($str)
{
    $result = file_get_contents("http://127.0.0.1:8888/service2?str=".$str);
    return strtoupper($result);
}

//微服务2
function service2($str)
{
    return md5($str);
}

//路由处理
$uri = $_SERVER['REQUEST_URI'];
if (preg_match("/^/service1?str=(.*)$/", $uri, $match)) {
    echo service1($match[1]);
} elseif (preg_match("/^/service2?str=(.*)$/", $uri, $match)) {
    echo service2($match[1]);
} else {
    echo "Unknown Request: ".$uri;
}

Le programme ci-dessus est un programme de simulation de microservice simple qui fournit deux services : service1 et service2. Le service 1 appellera le service 2 et convertira le résultat renvoyé au format majuscule. Le service 2 cryptera la chaîne d'entrée avec MD5 et la renverra.

Utilisez Swoole pour implémenter la version coroutine des microservices

2. Utilisez Swoole pour implémenter la version coroutine des microservices. Le code est le suivant :

<?php
$http = new SwooleHttpServer("0.0.0.0", 8888);

$http->on("request", function ($request, $response) {
    $uri = $request->server['request_uri'];
    if (preg_match("/^/service1?str=(.*)$/", $uri, $match)) {
        $result = go(function () use ($match) {
            $str = $match[1];
            $result = await service2($str);
            return strtoupper($result);
        });
        $response->end($result);
    } elseif (preg_match("/^/service2?str=(.*)$/", $uri, $match)) {
        $result = go(function () use ($match) {
            $str = $match[1];
            $result = await service2($str);
            return $result;
        });
        $response->end($result);
    } else {
        $response->end("Unknown Request: ".$uri);
    }
});

$http->start();

async function service1($str)
{
    $result = await service2($str);
    return strtoupper($result);
}

async function service2($str)
{
    //模拟异步IO操作
    usleep(1000000);
    return md5($str);
}

Dans le code ci-dessus, le serveur coroutine HTTP de Swoole est utilisé pour fournir des microservices et répondre. à l'URI demandé, analyser et appeler le service correspondant. Dans le traitement du service 1, le service service 2 est appelé et le résultat est renvoyé, mais la méthode appelante est asynchrone via la fonction go et le mot clé wait est utilisé pour attendre le résultat de l'appel asynchrone. Dans chaque implémentation de microservice, les opérations d'E/S asynchrones sont utilisées pour simuler les E/S du réseau réel afin de mieux refléter les caractéristiques des coroutines Swoole.

Résumé

Swoole fournit des capacités de programmation de coroutines très puissantes, qui peuvent aider les développeurs à écrire des programmes de communication réseau efficaces et performants. Lors de la mise en œuvre d'applications, les développeurs peuvent utiliser la technologie coroutine pour simplifier la programmation asynchrone, améliorer l'efficacité de l'exécution simultanée, etc. Dans l'exemple ci-dessus, nous avons utilisé Swoole pour implémenter une version coroutine des microservices, ce qui a considérablement amélioré les performances et la maintenabilité de l'application. Dans la mise en œuvre réelle, il est également nécessaire de sélectionner les opérations d'E/S asynchrones, les pools de connexions et autres technologies appropriés en fonction des caractéristiques de l'application pour optimiser davantage les performances de l'application.

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!