Les coroutines sont-elles utilisées dans swoole ?

Les coroutines sont utilisées dans swoole. Les coroutines sont principalement utilisées pour convertir les ressources concurrentes dans les threads en opérations collaboratives. Les coroutines peuvent être simplement comprises comme des threads, qui sont des threads plus légers. Cependant, les coroutines ne peuvent pas tirer parti des processeurs multicœurs et sont applicables. . Utilisé pour gérer les tâches gourmandes en E/S, les services à haute concurrence, etc.

L'environnement d'exploitation de ce tutoriel : système Windows 10, version Swoole 4, ordinateur DELL G3

Les coroutines sont-elles utilisées dans swoole

Les coroutines sont-elles utilisées dans swoole ? Le processus peut être simplement compris comme un thread, mais ce thread est en mode utilisateur et ne nécessite pas la participation du système d'exploitation. Le coût de création, de destruction et de commutation est très faible. Contrairement aux threads, les coroutines ne peuvent pas profiter du multicœur. Processeurs Si vous souhaitez profiter des processeurs multicœurs, vous devez vous fier au modèle multiprocessus de Swoole.

Caractéristiques des coroutines

Les développeurs peuvent utiliser l'écriture de code synchrone pour obtenir l'effet et les performances des E/S asynchrones sans aucune conscience, en évitant la logique de code discrète provoquée par les rappels asynchrones traditionnels et le code provoqué par la chute dans les rappels multicouches. Impossible à maintenir.

Dans le même temps, étant donné que la couche inférieure encapsule la coroutine, par rapport au framework de coroutine de couche PHP traditionnel, les développeurs n'ont pas besoin d'utiliser le mot-clé rendement pour identifier une opération d'E/S de coroutine, il n'est donc pas nécessaire d'avoir un in- compréhension approfondie de la sémantique de rendement et de chaque appel de premier niveau. Tous les appels de premier niveau sont modifiés en rendement, ce qui améliore considérablement l'efficacité du développement.

Les coroutines conviennent aux applications gourmandes en E/S, car les coroutines sont automatiquement planifiées lorsque les E/S sont bloquées, réduisant ainsi la perte de temps causée par le blocage des E/S.

Dormir 10 000 fois, lire, écrire, vérifier et supprimer des fichiers 10 000 fois, utiliser PDO et MySQLi pour communiquer avec la base de données 10 000 fois, créer un serveur TCP et plusieurs clients communiquent entre eux 10 000 fois, créer un serveur UDP et plusieurs clients communiquez entre vous 10 000 fois... tout est parfaitement réalisé en un seul processus en une seconde !

Scénarios applicables

Services à haute concurrence, tels que le système de vente flash, l'interface API haute performance, le serveur RPC, le pool de connexions, le chat IM, le serveur de jeu, l'Internet des objets, le serveur de messages, etc.

Exemple 1 :

Les utilisateurs peuvent créer une coroutine via la fonction go pour obtenir une exécution simultanée, comme indiqué dans le code suivant :

go(function () {
    echo "one" . PHP_EOL;
});
go(function () {
    echo "two" . PHP_EOL;
});
go(function () {
    echo "three" . PHP_EOL;
});

Chaque fois qu'un go apparaît, la couche inférieure créera automatiquement une coroutine après le programme. affiche le contenu, il se ferme ensuite automatiquement

Exemple 2 :

Les requêtes des clients peuvent être exécutées simultanément via des coroutines, et la planification lorsque le blocage des E/S provoqué par les coroutines est utilisée pour obtenir des services hautes performances. Ce qui suit est le mécanisme de report. implémente l'exécution simultanée des requêtes :

go(function () {
    // 协程 MySQL 客户端
    $mysql = new Swoole\Coroutine\MySQL();
    $mysql->connect([
        'host' => '172.17.0.1',
        'user' => 'root',
        'password' => 'root',
        'database' => 'swoole',
    ]);
    $mysql->setDefer();
    $mysql->query('select sleep(2);');
    
     print_r("time1: " . time() . PHP_EOL);
    
    // 协程 Redis 客户端
    $redis = new Swoole\Coroutine\Redis();
    $redis->connect('172.17.0.1', 6379);
    $redis->setDefer();
    $redis->set('name', '张三');
    $redis->recv();
    
    print_r("time2: " . time() . PHP_EOL);
    $redis->setDefer();
    $redis->get('name');
    $res1 = $mysql->recv();
    $res2 = $redis->recv();
    print_r(['result1: ' => $res1[0]['sleep'], 'result2: ' => $res2, 'time3: ' => time()]);
});

En prenant le code ci-dessus comme exemple, on peut simplement comprendre qu'en mode différé, les réponses aux requêtes de plusieurs clients sont simultanées. Après avoir défini setDefer(true), une requête est lancée via Redis. ou le client MySQL , n'attendra plus que le serveur renvoie le résultat, mais renverra true immédiatement après l'envoi de la requête. Après cela, vous pouvez continuer à lancer d'autres requêtes Redis et MySQL, et enfin utiliser la méthode recv() pour recevoir le contenu de la réponse.

Remarques

Si le même client coroutine est partagé entre plusieurs coroutines, le programme de blocage de synchronisation est différent. La coroutine traite les demandes simultanément, de sorte que plusieurs demandes peuvent être traitées en parallèle en même temps. entraînera une confusion des données entre les différentes coroutines.

Les coroutines synchronisent la logique asynchrone d'origine, mais la commutation des coroutines se produit implicitement, de sorte que la cohérence des variables globales et des variables statiques ne peut pas être garantie avant et après la commutation de coroutines.

Apprentissage recommandé : Tutoriel swoole

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!