Comparaison entre la coroutine Swoole et le mode de synchronisation fpm traditionnel

Si les tableaux sont l'essence même de PHP, si vous ne pouvez pas jouer avec les tableaux, vous ne pouvez pas du tout être considéré comme capable d'utiliser PHP. La même chose s'applique aux coroutines pour Swoole. Si vous ne comprenez pas les coroutines et utilisez Swoole, vous les utilisez aveuglément.

Tout d'abord, Swoole ne peut s'exécuter qu'en mode ligne de commande (Cli), nous utilisons donc la ligne de commande pour le développement et le débogage, pas php-fpm/apache etc.

Dans Swoole, nous pouvons utiliser `SwooleCoroutine::create()` pour créer des coroutines, ou vous pouvez également utiliser l'abréviation `go()`.

Première introduction à la coroutine Swoole

go(function(){
    go(function(){
        echo 0, PHP_EOL;
    });
    echo 1, PHP_EOL;
});
go(function(){
    echo 2, PHP_EOL;
});
go(function(){
    echo 3, PHP_EOL;
});

Résultats d'exécution :

0
1
2
3

Comparaison entre la coroutine Swoole et le mode synchrone

Nous disons que la coroutine Swoole est adaptée aux scénarios gourmands en E/S. Dans le même environnement de configuration matérielle, elle offrira plus d'accès que le mode synchrone traditionnel.

Les requêtes de lecture et d'écriture de fichiers et de communication réseau (MySQL, Redis, HTTP, etc.) que nous connaissons sont tous des scénarios gourmands en E/S.

Supposons qu'une requête SQL prenne 100 ms. Dans le mode de synchronisation traditionnel, le processus actuel ne peut pas effectuer d'autres opérations pendant ce temps de 100 ms. Si vous souhaitez exécuter ce SQL dix fois, cela peut prendre plus d'une seconde.

Si vous utilisez des coroutines, bien que différentes coroutines soient exécutées dans l'ordre, pendant la période d'attente précédente de 100 ms, la couche inférieure planifiera le CPU pour effectuer les opérations des autres coroutines. En d'autres termes, il est possible qu'avant que la première requête ne renvoie des résultats, plusieurs autres requêtes aient été envoyées à MySQL et soient en cours d'exécution. Si dix coroutines sont ouvertes et que ce SQL est exécuté séparément, cela ne peut prendre que plus de 100 ms.

Le code du test est le suivant :

Swoole\Runtime::enableCoroutine(); // 开启一键协程化
 
function work()
{
    $pdo = new \PDO('mysql:host=127.0.0.1;dbname=db_test', 'root', 'root');
    $pdo->exec('select SLEEP(0.1)'); // 模拟sql需要执行 100ms 的情况
}
$time = microtime(true);
for($i = 0; $i < 10; ++$i)
{
    work();
}
echo &#39;time: &#39;, (microtime(true) - $time), &#39;s&#39;, PHP_EOL;
$time = microtime(true);
for($i = 0; $i < 10; ++$i)
{
    go(&#39;work&#39;);
}
swoole_event_wait(); // 等待所有协程执行完
echo &#39;time: &#39;, (microtime(true) - $time), &#39;s&#39;, PHP_EOL;

Résultat de l'exécution :

time: 1.0326268672943s
time: 0.10734605789185s

Le code ci-dessus peut être imaginé comme le temps nécessaire à un seul processus pour traiter 10 requêtes. Chaque requête nécessite l'exécution d'une instruction SQL qui prend 100 ms.

Le mode synchrone, qui prend environ 1 seconde, est fpm. On voit que rien ne peut être fait en attendant 100 ms.

Le modèle Coroutine, qui prend environ 0,1 seconde, est Swoole. Pendant la période d'attente de 100 ms, la coroutine actuelle sera suspendue et la planification sous-jacente permettra au CPU d'effectuer les opérations d'autres coroutines.

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!