Un processus est l'instance de démarrage d'une application. Ressources de fichiers indépendantes, ressources de données et espace mémoire.
Qu'est-ce qu'un fil de discussion ?
Les threads appartiennent aux processus et sont les exécuteurs des programmes. Un processus contient au moins un thread principal et peut également avoir plusieurs threads enfants. Les threads ont deux stratégies de planification, l’une est la planification en temps partagé et l’autre est la planification préemptive.
Mon groupe Penguin officiel
Qu'est-ce qu'une coroutine ?
Les coroutines sont des threads légers, les coroutines appartiennent également aux threads et les coroutines sont exécutées dans les threads. La planification des coroutines est modifiée manuellement par l'utilisateur, elle est donc également appelée thread de l'espace utilisateur. La création, la commutation, la suspension et la destruction de coroutines sont toutes des opérations mémoire et la consommation est très faible. La stratégie de planification des coroutines est la suivante : planification collaborative.
Le principe de la coroutine Swoole
Puisque Swoole4 est monothread et multi-processus, il n'y aura qu'une seule coroutine exécutée dans le même processus en même temps.
Le serveur Swoole reçoit des données et déclenche le rappel onReceive dans le processus de travail pour générer un Ctrip. Swoole crée un Ctrip correspondant pour chaque requête. Des sous-coroutines peuvent également être créées dans des coroutines.
L'implémentation sous-jacente de la coroutine est monothread, il n'y a donc qu'une seule coroutine travaillant en même temps, et l'exécution de la coroutine est en série.
Par conséquent, lorsque le multitâche et le multi-coroutine sont exécutés, lorsqu'une coroutine est en cours d'exécution, les autres coroutines cesseront de fonctionner. La coroutine actuelle se bloquera lors de l'exécution d'opérations d'E/S bloquantes et le planificateur sous-jacent entrera dans la boucle d'événements. Lorsqu'il y a un événement de fin d'E/S, le planificateur sous-jacent reprend l'exécution de la coroutine correspondant à l'événement. . Par conséquent, les coroutines n'ont pas de consommation de temps d'E/S et sont très adaptées aux scénarios d'E/S à haute concurrence. (Comme le montre l'image ci-dessous)
Processus d'exécution de la coroutine de Swoole
La coroutine n'a pas d'E/S et attend une exécution normale, le code PHP ne provoquera pas de changement de flux d'exécution
Lorsque la coroutine rencontre une IO, elle changera immédiatement de contrôle. Une fois l'IO terminée, le flux d'exécution sera commuté. revenez à la coroutine d'origine. Cliquez sur
coroutine et coroutine parallèle pour exécuter en séquence, la même logique que le processus d'exécution imbriqué de coroutine
précédent. est entré couche par couche de l'extérieur vers l'intérieur jusqu'à ce que l'IO se produise, puis passe à la coroutine externe. La coroutine parent n'attendra pas la fin de la coroutine enfant
go() est l'abréviation de Co::create(), utilisée pour créer une coroutine qui accepte le rappel comme paramètre Le code dans. le rappel sera exécuté dans cette coroutine nouvellement créée.
Remarques : SwooleCoroutine peut être abrégé en Co
Le résultat de l'exécution du code ci-dessus :
root@b98940b00a9b /v/w/c/p/swoole# php co.phphello go1
hello main
hello go2
Copier après la connexion
Le résultat de l'exécution ne semble pas différent de l'ordre dans lequel nous écrivons habituellement le code. Le processus d'exécution réel :
Exécutez ce code, le système démarre un nouveau processus
rencontre
, et une coroutine est générée dans le processus en cours. Le processus génère go(), la coroutine quitte heelo go1
et le processus continue d'exécuter le code vers le bas. , et le processus génère
hello main
puis génère une coroutine , sortie
dans la coroutine, quittez la coroutine heelo go2
. Exécutez ce code, le système démarre un nouveau processus. Si vous ne comprenez pas cette phrase, vous pouvez utiliser le code suivant :
// co.php<?phpsleep (100);
Copier après la connexion
Exécuter et utiliser
pour afficher les processus dans le système :ps aux
root@b98940b00a9b /v/w/c/p/swoole# php co.php &⏎
root@b98940b00a9b /v/w/c/p/swoole# ps auxPID USER TIME COMMAND
1 root 0:00 php -a 10 root 0:00 sh 19 root 0:01 fish 749 root 0:00 php co.php 760 root 0:00 ps aux
⏎
Copier après la connexion
Faisons un léger changement et expérimentons la planification des coroutines :
use Co;go(function () {
Co::sleep(1); // 只新增了一行代码
echo "hello go1 \n";});echo "hello main \n";go(function () {
echo "hello go2 \n";});
Copier après la connexion
Fonctions de fonction et Co::sleep() Presque, mais cela simule l'attente d'IO (IO sera discuté en détail plus tard). Les résultats de l'exécution sont les suivants : sleep()
root@b98940b00a9b /v/w/c/p/swoole# php co.phphello main
hello go2
hello go1
Copier après la connexion
Pourquoi n'est-il pas exécuté séquentiellement ? Le processus d'exécution réel :
Exécutez ce code, le système démarre un nouveau processus
rencontre
et génère une coroutine dans le processus en cours go()
rencontre un blocage d'E/S dans la coroutine (voici
attente d'E/S simulée), la coroutine abandonne le contrôle, entre dans la file d'attente de planification de la coroutine Co::sleep()
et le processus continue de s'exécuter vers le bas, sort
hello main
et exécute la coroutine suivante, sort
hello go2
La coroutine précédente est prête, continue l'exécution et sort
hello go1
À ce stade, vous pouvez déjà voir la relation entre la coroutine et le processus dans swoole, ainsi que la planification de la coroutine, changeons le programme tout à l'heure :
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
