Comment utiliser des tâches asynchrones pour implémenter le traitement en arrière-plan en PHP

Dans le développement web, certaines tâches sont longues à réaliser, comme le traitement des données, le téléchargement de fichiers, l'envoi d'e-mails, etc. Si ces opérations sont effectuées au premier plan, cela entraînera une mauvaise expérience utilisateur et empêchera même la page de répondre pendant une longue période. Par conséquent, l'utilisation de tâches asynchrones peut placer ces tâches en arrière-plan, améliorer la capacité de concurrence du système et également rendre l'expérience utilisateur et l'interaction au premier plan plus fluides.

PHP, en tant que langage de script côté serveur populaire, offre également un bon support pour la mise en œuvre de tâches asynchrones. Cet article explique comment utiliser des tâches asynchrones pour implémenter le traitement en arrière-plan en PHP.

Principes et méthodes

Le principe de mise en œuvre des tâches asynchrones est de traiter les tâches en arrière-plan afin que le programme puisse effectuer d'autres tâches pendant cette période. Cette fonctionnalité peut être obtenue grâce aux modules d'extension PHP suivants :

1. pcntl : réalise des tâches en arrière-plan via le processus Fork.
2. posix : utilisé pour gérer les appels système liés aux processus, tels que les signaux, les verrous, etc.
3. swoole : un moteur de communication réseau asynchrone, parallèle et coroutine hautes performances basé sur la technologie epoll.

Parmi eux, swoole est le module d'extension le plus récent et le plus recommandé, qui prend en charge le plus de fonctionnalités, est le plus rapide et possède les fonctions les plus puissantes.

Utilisez pcntl pour implémenter des tâches en arrière-plan

pcntl est une extension PHP qui fournit un ensemble de fonctions de contrôle de processus. Grâce à la fonction pcntl_fork(), un processus enfant peut être créé pour gérer les tâches en arrière-plan. La méthode d'implémentation spécifique est la suivante :

// 创建子进程
$pid = pcntl_fork();

if ($pid === -1) {
    die('could not fork');
}
// 父进程
elseif ($pid) {
    // 执行父进程代码...
    pcntl_wait($status);
}
// 子进程
else {
  // 执行子进程代码...
  exit;
}

Dans le code ci-dessus, la fonction pcntl_fork() renvoie une valeur entière si la valeur est -1, cela signifie que la création du processus enfant a échoué si la valeur est 0, cela signifie qu'il s'agit actuellement d'un processus enfant ; si la valeur est supérieure à 0 , indiquant qu'il s'agit actuellement du processus parent.

À ce stade, le processus enfant peut effectuer des tâches en arrière-plan, telles que des tâches planifiées, le traitement de fichiers, etc. Il convient de noter que l'utilisation de pcntl doit être évitée dans un environnement en ligne car pcntl ne fonctionne qu'avec des scripts de ligne de commande.

Utilisez Posix pour implémenter les tâches en arrière-plan

Pour les serveurs Web comme Apache et Nginx, vous devez utiliser les extensions Posix pour la gestion des processus. posix fournit certaines fonctions liées à la gestion des processus, telles que posix_kill(), posix_getpid(), etc. Parmi elles, la fonction posix_kill() peut envoyer des signaux au processus pour contrôler son comportement.

La méthode d'utilisation de posix pour implémenter les tâches en arrière-plan est la suivante :

// 创建子进程
$pid = posix_getpid();
$child_pid = pcntl_fork();

if (0 === $child_pid) {
  // 子进程代码...
  sleep(10);
  posix_kill($pid, SIGUSR1); //给父进程发送SIGUSR1信号
  exit();
}

// 父进程等待信号
pcntl_signal(SIGUSR1, function ($sig) {
  //在这里执行异步任务
  echo "Received signal: {$sig}
";
  die();
});

Dans le processus enfant, la fonction sleep() représente le temps d'exécution de la tâche asynchrone. Lorsque la tâche asynchrone est terminée, utilisez la fonction posix_kill() pour envoyer le signal SIGUSR1 au processus parent, indiquant que la tâche est terminée. Dans le processus parent, la fonction pcntl_signal() est utilisée pour attendre l'arrivée du signal, qui représente l'achèvement de la tâche asynchrone.

Utilisez swoole pour implémenter des tâches en arrière-plan

swoole est un framework de coroutine PHP asynchrone hautes performances qui implémente un modèle de programmation asynchrone de manière pilotée par les événements. swoole fournit une classe swoole_process pour gérer la création, l'exécution et la sortie des processus enfants. Le code d'implémentation spécifique est le suivant :

$process = new swoole_process(function (swoole_process $worker) {
  // 子进程执行的代码
});

$pid = $process->start();
$swoole_event_add($process->pipe, function ($pipe) use ($process) {
  $recv = $process->read();
  echo "received data: ". $recv;
});

$process->write('hello'); // 向子进程中发送消息

Dans le code ci-dessus, un sous-processus est créé à l'aide de la classe swoole_process, et le sous-processus peut être démarré via la méthode start(). Lorsque le programme du processus enfant doit envoyer un message au processus principal, utilisez la méthode write() pour écrire des données dans le canal. Un autre processus peut lire les données dans le canal en écoutant les événements du canal. De cette manière, la communication inter-processus est réalisée, mettant ainsi en œuvre des tâches asynchrones.

Résumé

Les tâches asynchrones sont largement utilisées dans le développement Web. Les tâches asynchrones peuvent être implémentées en PHP via les extensions pcntl, posix et swoole. Parmi elles, le swoole est la méthode la plus complète et la plus recommandée. En comprenant ces méthodes, les développeurs peuvent choisir la méthode appropriée pour implémenter des tâches asynchrones en fonction des besoins métier spécifiques. Cela contribuera à améliorer les capacités de concurrence du système et l’expérience utilisateur.

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!