Swoole en action : Comment utiliser les coroutines pour les opérations de mise en cache

Ces dernières années, Swoole, en tant que framework de réseau asynchrone hautes performances, a été favorisé par les développeurs et largement utilisé dans divers domaines. Les coroutines sont l'un des concepts très importants dans l'utilisation de Swoole, qui nous permettent d'écrire du code asynchrone de manière synchrone. Cet article expliquera comment utiliser les coroutines pour les opérations de mise en cache dans Swoole et fournira des exemples de code pratiques.

1. Qu'est-ce qu'une coroutine ? Une coroutine est un thread léger en mode utilisateur. Il est géré par les programmeurs via du code, évitant la consommation et le changement de threads système. Dans Swoole, les coroutines peuvent être utilisées pour résoudre des problèmes de fonctionnement réseau gourmands en E/S, tels que les connexions à des bases de données, les opérations Redis, etc. La coroutine peut activement abandonner le contrôle lorsqu'elle rencontre une opération d'E/S et attendre la fin de l'opération avant de reprendre l'exécution.

2. Prise en charge de la coroutine par Swoole

Swoole a introduit la prise en charge de la coroutine depuis la version 1.8.0, qui fournit une série d'API pour implémenter la planification des coroutines, notamment coroutine, go, defer, canal, etc.

1. Coroutine

La coroutine est l'opération de base de la coroutine. Elle nous permet de convertir une fonction en coroutine, par exemple :

function test()
{
    echo "start
";
    Coroutine::sleep(1);
    echo "end
";
}

Coroutine::create('test');
echo "hello
";

Dans cet exemple, nous convertissons la fonction test en coroutine et utilisons Coroutine::create. () pour créer une coroutine. Dans la coroutine, nous utilisons Coroutine::sleep() pour simuler une opération d'E/S. Cette opération entraînera une pause de la coroutine pendant 1 seconde, puis elle reprendra et continuera à afficher "end". Enfin, "hello" est affiché, ce qui démontre la nature asynchrone de la coroutine.

2. go

go est une fonction spéciale qui nous permet d'exécuter une fonction en tant que coroutine, par exemple :

go(function(){
    echo "hello
";
    Coroutine::sleep(1);
    echo "world
";
});
echo "start
";

Dans cet exemple, nous utilisons go() pour exécuter une fonction anonyme. Dans la fonction, nous affichons « bonjour », faisons une pause d'1 seconde et affichons « monde » dans l'ordre. Enfin, "start" est affiché, ce qui prouve que nous utilisons des coroutines pour exécuter cette fonction simultanément.

3. defer

defer nous permet d'effectuer un travail de nettoyage à la fin de la coroutine, comme fermer les connexions à la base de données, libérer des ressources, etc. Son utilisation est la suivante :

go(function(){
    $db = new Redis();
    $db->connect('127.0.0.1', 6379);
    defer(function() use ($db) {
        $db->close();
    });

    $db->set('key', 'value');
    Coroutine::sleep(1);
    $value = $db->get('key');
    echo $value."
";
});

Dans cet exemple, nous utilisons defer à la fin de la coroutine La connexion Redis est fermée. Si nous n'utilisons pas defer, nous risquons d'oublier de fermer la connexion à la fin de la coroutine, provoquant une fuite du nombre de connexions.

4. Channel

channel est un mécanisme de type tuyau fourni par Swoole, qui permet la communication entre plusieurs coroutines, telles que :

$chan = new CoroutineChannel(1);

go(function() use($chan) {
    $data = Coroutine::getuid();
    $chan->push($data);
});

$data = $chan->pop();
echo $data."
";

Dans cet exemple, nous avons créé un canal d'une capacité de 1 , puis avons poussé un morceau de les données sur le canal dans une coroutine, puis placez les données dans le canal dans une autre coroutine et sortez-les. L'utilisation de canaux nous permet de transférer des données entre coroutines et de compléter le traitement des tâches collaboratives.

3. Cache d'opération de coroutine

Dans le développement réel, le cache est un composant très important. Il peut réduire la pression sur la base de données et accélérer la lecture des données grâce aux accès au cache. Dans Swoole, nous pouvons utiliser des bases de données en mémoire telles que Redis pour implémenter la mise en cache, et en même temps, nous pouvons utiliser des coroutines pour améliorer les performances de concurrence du cache.

1. Connectez-vous à Redis

Nous utilisons le client Redis coroutine de Swoole pour nous connecter à la base de données Redis et effectuer des opérations simultanément :

$redis = new SwooleCoroutineRedis();
$redis->connect('127.0.0.1', 6379);

go(function () use ($redis) {
    $redis->set('name', 'Bob');
    $name = $redis->get('name');
    echo "name=$name
";
});

go(function () use ($redis) {
    $redis->set('age', 18);
    $age = $redis->get('age');
    echo "age=$age
";
});

SwooleCoroutine::sleep(1);

Dans cet exemple, nous utilisons le client Redis coroutine de Swoole pour connecter la base de données Redis. Ensuite, nous avons effectué des opérations de lecture et d'écriture sous forme de coroutines et avons généré les résultats pertinents dans les coroutines. Enfin, utilisez SwooleCoroutine::sleep() pour attendre un certain temps afin de vous assurer que la coroutine est terminée. Vous pouvez vous connecter et exploiter d'autres bases de données en mémoire de la même manière.

2. Opération cache

Après la connexion à Redis, nous pouvons utiliser une série de commandes de cache pour fonctionner. Par exemple, pour définir les données mises en cache, vous pouvez utiliser la méthode set() :

$redis->set('key', 'value');

où « clé » est la clé des données mises en cache et « valeur » est la valeur des données mises en cache. Pour lire les données mises en cache, vous pouvez utiliser la méthode get() :

$value = $redis->get('key');

Dans la coroutine, nous pouvons utiliser les commandes ci-dessus pour fonctionner simultanément. Par exemple :

go(function() use($redis){
    $redis->set('key1', 'value1');
    $value1 = $redis->get('key1');
    echo "key1=$value1
";
});

go(function() use($redis){
    $redis->set('key2', 'value2');
    $value2 = $redis->get('key2');
    echo "key2=$value2
";
});

SwooleCoroutine::sleep(1);

Dans cet exemple, nous définissons et lisons respectivement deux données mises en cache dans deux coroutines, puis les exploitons simultanément. Cela prouve que les coroutines peuvent améliorer les performances de concurrence des données mises en cache.

3. Opération cache et MySQL

Dans les applications pratiques, nous devons généralement combiner le cache et MySQL pour les opérations, telles que lire d'abord les données du cache, et s'il n'y a pas de cache, lire depuis MySQL. Dans le développement de la coroutine de Swoole, nous pouvons utiliser une méthode similaire à la suivante pour implémenter cette opération :

$redis = new SwooleCoroutineRedis();
$redis->connect('127.0.0.1', 6379);

$mysql = new SwooleCoroutineMySQL();
$mysql->connect([
    'host' => '127.0.0.1',
    'port' => 3306,
    'user' => 'root',
    'password' => '123456',
    'database' => 'test',
]);

go(function() use($redis, $mysql) {
    $name = $redis->get('name');
    if($name === false) {
        $result = $mysql->query('select * from user where id=1');
        if(!empty($result)) {
            $name = $result[0]['name'];
            $redis->set('name', $name);
        }
    }
    echo "name=$name
";
});

go(function() use($redis, $mysql) {
    $age = $redis->get('age');
    if($age === false) {
        $result = $mysql->query('select * from user where id=1');
        if(!empty($result)) {
            $age = $result[0]['age'];
            $redis->set('age', $age);
        }
    }
    echo "age=$age
";
});

SwooleCoroutine::sleep(1);

Dans cet exemple, nous utilisons la méthode d'opération coroutine, essayez d'abord de lire les données du cache, si elles ne sont pas dans le cache , les données sont lues depuis MySQL. Lors de l'utilisation de MySQL, nous utilisons également des coroutines pour éviter de bloquer les threads et améliorer l'efficacité. Enfin, nous avons imprimé les résultats de lecture pour prouver l'exactitude de cette méthode de fonctionnement.

Ce qui précède est la méthode d'implémentation spécifique d'utilisation des coroutines pour les opérations de cache dans Swoole. Les coroutines peuvent améliorer l'efficacité et les performances de concurrence des opérations de cache et peuvent être combinées avec d'autres opérations telles que MySQL. Dans le développement réel, nous pouvons pratiquer de la manière ci-dessus et apporter des ajustements et des changements en fonction de la situation réelle.

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!