Français
Français
Dans la programmation multithread PHP, comme l'utilisation de l'extension Pthreads, un contrôle précis du temps de sommeil du thread est d'une grande signification pour le réglage des performances et le contrôle simultané. Time_nanosleep est une fonction utilisée pour atteindre un sommeil en nanoseconde. Il semble très adapté à ce type de scénarios en surface, mais il y a des malentendus et des précautions dans une utilisation réelle. Cet article explorera en profondeur la bonne manière qu'il est utilisé dans un environnement multithread.
Time_nanosleep (int $ seconds, int $ nanoseconds): bool | array est une fonction de sommeil de haute précision fournie par PHP, permettant aux développeurs de spécifier le temps de sommeil en deux dimensions de secondes et de nanosecondes. Par exemple:
time_nanosleep(0, 500000); // Dormir0.5millisecondes
Cette fonction fonctionne bien dans les threads uniques, mais dans un environnement multi-thread, ses performances sont affectées par le mécanisme de planification du système d'exploitation et la stratégie de planification de threads de PHP.
Lors de l'utilisation de PTHEADS, chaque thread est un thread d'espace utilisateur et sa planification dépend toujours de la tranche de temps des threads au niveau du noyau du système d'exploitation. Si vous appelez fréquemment Time_nanosleep dans les fils d'enfants pour un contrôle de haute précision, les problèmes suivants peuvent se produire:
Délai d'incertitude : le temps de sommeil du fil est facilement affecté par la planification du thread du système, ce qui entraîne l'incapacité à réaliser une véritable précision "nanoseconde".
Déche des ressources CPU : Si vous utilisez le sommeil pendant une courte période excessivement, vous changerez fréquemment de contextes de thread et occuperez les ressources système.
while (some_condition()) {
// Ce n'est pas recommandé
time_nanosleep(0, 100000); // Dormir100Microsecondes
}
Cette méthode intensifiera la concurrence des fils dans des scénarios de concurrence élevés. Il est préférable d'utiliser un mécanisme de verrouillage ou un mécanisme de signalisation plus approprié.
Dans un environnement multithread, Time_nanosleep est plus adapté pour coopérer avec une certaine logique d'attente de verrouillage, comme:
class WorkerThread extends Thread {
public function run() {
while (true) {
if ($this->shouldProcess()) {
// Manipuler les tâches
} else {
// S'il n'y a pas de tâche，短暂Dormir，libérerCPU
time_nanosleep(0, 500000); // 0.5millisecondes
}
}
}
private function shouldProcess() {
// Jugement de la logique commerciale réelle
return rand(0, 1) === 1;
}
}
$worker = new WorkerThread();
$worker->start();
Le sommeil ici est de réduire l'occupation du processeur, et non de contrôler un retard précis, de sorte que la "précision" de Nanosleep est d'économiser des ressources, plutôt que de contrôler avec précision le retard d'une certaine opération.
Si vous souhaitez contrôler l'intervalle entre le démarrage et la fin d'une tâche est terminé dans la plage de "temps précis", vous devez le faire:
$start = hrtime(true); // Horodatage nanoseconde
do_something();
$end = hrtime(true);
$elapsed = $end - $start;
$target = 1000000; // 1millisecondes
if ($elapsed < $target) {
$remaining = $target - $elapsed;
$seconds = intdiv($remaining, 1000000000);
$nanoseconds = $remaining % 1000000000;
time_nanosleep($seconds, $nanoseconds);
}
Cette méthode peut garantir que le temps d'exécution de la tâche est "rempli" sur la longueur attendue et convient aux scénarios tels que le traitement de la limite de vitesse, les algorithmes de limitation, les tâches de synchronisation, etc.
Si vous avez besoin de mettre en œuvre un contrôle de retard de haute précision dans un environnement à haute coeur, il est recommandé d'utiliser des extensions de PHP qui soutiennent les coroutines telles que Swoole , dont le mécanisme de planification de la coroutine est beaucoup plus efficace que les Pthreads traditionnels.
Dans l'environnement GO Coroutine de Swoole, vous pouvez utiliser Usleep ou Swoole fourni CO :: Sleep pour obtenir un traitement plus précis et non bloquant:
go(function () {
Co::sleep(0.001); // 1ms
});
C'est plus pratique et fiable que la combinaison de Pthreads + Time_nanosleep .
Dans l'environnement multithread de PHP, bien que Time_nanosleep puisse fournir un contrôle de retard submillisisecond, il n'est pas réaliste d'atteindre la "précision réelle de la nanoseconde" car son effet d'exécution est limité par la planification du système d'exploitation, le commutation de contexte de thread et l'environnement de course de PHP. Il est mieux pour la réduction de la charge du processeur plutôt qu'un contrôle de synchronisation précis.
S'il existe des exigences plus élevées pour la précision des retards, il est recommandé de combiner des fonctions de temps de haute précision, des architectures axées sur les événements ou d'adopter un cadre de coroutine plus moderne pour obtenir une logique de contrôle plus stable.
