La différence entre la coroutine swoole et l'asynchrone

À partir de la version 4.0, Swoole fournit des fonctionnalités complètes de coroutine + canal, apportant un nouveau modèle de programmation CSP.

La couche application peut utiliser une programmation entièrement synchrone et la couche inférieure implémente automatiquement les E/S asynchrones. (Apprentissage recommandé : tutoriel vidéo swoole)

go(function () {
    $redis = new Swoole\Coroutine\Redis();
    $redis->connect('127.0.0.1', 6379);
    $val = $redis->get('key');
});

La version 4.0.0 ou supérieure ne prend en charge que PHP7

Il a été supprimé depuis la version 4.0. 1 --enable-coroutine option de compilation, remplacée par une configuration dynamique

Coroutine peut être comprise comme un pur thread en mode utilisateur, qui bascule par coopération plutôt que par préemption. Par rapport aux processus ou aux threads, toutes les opérations des coroutines peuvent être effectuées en mode utilisateur et les coûts de création et de changement sont inférieurs.

Swoole peut créer une coroutine correspondante pour chaque requête et planifier raisonnablement la coroutine en fonction de l'état de l'IO. Cela apportera les avantages suivants :

Les utilisateurs de développement peuvent utiliser le mode synchrone. écriture de code 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 en étant piégé dans des rappels multicouches, ce qui entraîne un code non maintenable

En même temps, en raison à La couche inférieure encapsule les coroutines, donc par rapport au cadre 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 une compréhension approfondie de la sémantique de rendement et appelez chaque niveau. Tous sont modifiés pour produire, ce qui améliore considérablement l'efficacité du développement

et peut répondre aux besoins de la plupart des développeurs. Pour les protocoles privés, les développeurs peuvent utiliser l'interface TCP ou UDP de la coroutine pour une encapsulation pratique.

Si vous devez effectuer des opérations fastidieuses dans le programme Serveur, telles que l'envoi de diffusions à un serveur de chat ou l'envoi d'e-mails à un serveur Web. Si vous exécutez ces fonctions directement, le processus en cours sera bloqué, ce qui entraînera une réponse lente du serveur.

Swoole fournit la fonction de traitement de tâche asynchrone, qui peut fournir une tâche asynchrone au pool de processus TaskWorker pour exécution sans affecter la vitesse de traitement de la requête en cours.

Code du programme

Basé sur le premier serveur TCP, seules deux fonctions de rappel d'événement, onTask et onFinish, doivent être ajoutées. De plus, le nombre de processus de tâche doit être défini. Le nombre approprié de processus de tâche peut être configuré en fonction de la consommation de temps et du volume de la tâche.

$serv = new swoole_server("127.0.0.1", 9501);

//设置异步任务的工作进程数量
$serv->set(array('task_worker_num' => 4));

$serv->on('receive', function($serv, $fd, $from_id, $data) {
    //投递异步任务
    $task_id = $serv->task($data);
    echo "Dispath AsyncTask: id=$task_id\n";
});

//处理异步任务
$serv->on('task', function ($serv, $task_id, $from_id, $data) {
    echo "New AsyncTask[id=$task_id]".PHP_EOL;
    //返回任务执行的结果
    $serv->finish("$data -> OK");
});

//处理异步任务的结果
$serv->on('finish', function ($serv, $task_id, $data) {
    echo "AsyncTask[$task_id] Finish: $data".PHP_EOL;
});

$serv->start();

Après avoir appelé $serv->task(), le programme revient immédiatement et continue d'exécuter le code. La fonction de rappel onTask est exécutée de manière asynchrone dans le pool de processus Task. Une fois l'exécution terminée, appelez $serv->finish() pour renvoyer le résultat.

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!