Expérience pratique Swoole : utilisation de coroutines pour le traitement des e-mails à haute concurrence

Avec le développement rapide de la technologie Internet et l'expansion continue des scénarios d'application, les services de messagerie sont devenus un élément indispensable du travail quotidien des entreprises/particuliers. Cependant, dans l'envoi d'e-mails à grande échelle, une simultanéité élevée devient souvent un goulot d'étranglement, comme des connexions ou reconnexions fréquentes au serveur SMTP, la consommation de la file d'attente des messages et d'autres opérations. Ces opérations nécessitent beaucoup de temps et de ressources système, affectant l'ensemble de l'envoi d'e-mails. .l'efficacité des processus. Alors, comment parvenir à un traitement efficace des e-mails avec un minimum de ressources ?

La pratique a montré que l'utilisation de coroutines pour le traitement des e-mails à haute concurrence dans Swoole est une méthode très réalisable et efficace. Cet article présentera quelques pratiques de développement sur la façon d'utiliser la fonctionnalité coroutine de Swoole pour obtenir un traitement simultané élevé des e-mails.

1. Introduction aux coroutines

Les coroutines sont des threads légers, qui peuvent être considérés comme un compromis entre les processus et les threads. Les coroutines ont les caractéristiques suivantes :

1. Changement de contexte à faible coût
2. Aucun mécanisme de verrouillage requis
3. Occupation légère des ressources# 🎜🎜#
Collaboration multitâche

1. SwooleCoroutinecreate(callable $fn, bool $coroutine_params) : Créez une coroutine.
2. SwooleCoroutine::yield() : suspend l'exécution de la coroutine actuelle et ne libère pas de ressources CPU.
3. SwooleCoroutine::resume($coroutine_id) : Reprendre la coroutine spécifiée.
4. 2. Pratique : utilisez la fonctionnalité coroutine de Swoole pour obtenir un traitement simultané élevé des e-mails

#🎜🎜 ## 🎜🎜#Il est assez simple d'utiliser la fonctionnalité coroutine de Swoole pour gérer l'envoi d'e-mails. Nous pouvons envoyer des e-mails basés sur la bibliothèque PHPMailer.
1. Vous devez d'abord initialiser le client SMTP et définir les paramètres liés au serveur SMTP :

try {
   $mail = new PHPMailer;
   $mail->isSMTP();
   $mail->SMTPDebug  = 0;
   $mail->SMTPAuth  = true;
   $mail->SMTPSecure = 'tls';
   $mail->Host   = "smtp.example.com";
   $mail->Port   = "465";
   $mail->CharSet = "utf-8";
   $mail->Username = "user@example.com";
   $mail->Password = "password";
   $mail->setFrom('user@example.com', 'Mailer');
   $mail->addAddress('recipient@example.com', 'Recipient');
   $mail->isHTML(true);
   $mail->Subject = 'Test email';
   $mail->Body    = 'This is the HTML message body <b>in bold!</b>';
   $mail->AltBody = 'This is the body in plain text for non-HTML mail clients';
}
catch (Exception $e) {
   echo "Message could not be sent. Mailer Error: {$mail->ErrorInfo}";
   exit;
}

Ensuite, nous utiliserons la fonctionnalité coroutine de Swoole pour envoyer plusieurs e-mails simultanément :

$tasks = array();
for ($i = 0; $i < $concurrency; $i++) {
   $tasks[] = SwooleCoroutine::create(function () use ($mail) {
       $result = $mail->send();
       if (!$result) {
           echo "Mailer Error: {$mail->ErrorInfo}
";
       } else {
           echo "Message sent successfully!
";
       }
   });
}
SwooleCoroutine::wait($tasks);

Dans cet exemple, nous utilisons la fonction SwooleCoroutine::create() pour créer plusieurs coroutines . Ces coroutines enverront plusieurs e-mails simultanément. Enfin, nous utilisons la fonction SwooleCoroutine::wait() pour attendre que toutes les coroutines terminent leur exécution.

Lorsque le serveur SMTP reçoit un grand nombre de requêtes de connexion, il peut rejeter la plupart des requêtes dans un pendant une courte période, nous devons alors terminer la maintenance de l'état du serveur SMTP dans le traitement de la coroutine. Par exemple, lorsque le serveur SMTP rejette la demande, nous devons attendre un certain temps avant de réessayer d'envoyer l'e-mail. À ce stade, nous devons utiliser la fonction SwooleCoroutinesleep() pour y parvenir.

Par exemple, nous pouvons utiliser le code suivant pour maintenir l'état du serveur SMTP :

3. $max_retry_count = 5;
   for ($i = 0; $i < $concurrency; $i++) {
      $tasks[] = SwooleCoroutine::create(function () use ($mail, $max_retry_count) {
          $retry_count = 0;
          $result = false;
          while (!$result && $retry_count++ < $max_retry_count) {
              $result = $mail->send();
              if (!$result) {
                  echo "Mailer Error: {$mail->ErrorInfo}
   ";
                  if ($retry_count < $max_retry_count) {
                      $sleep_time = 2 ** ($retry_count - 1);
                      echo "sleep $sleep_time seconds before retrying...
   ";
                      SwooleCoroutine::sleep($sleep_time);
                  }
              } else {
                  echo "Message sent successfully!
   ";
              }
          }
      });
   }

   Copier après la connexion
   Dans cet exemple de code, nous réessayerons d'envoyer l'e-mail et échouerons à chaque fois dormir un moment. Chaque temps de sommeil augmentera à mesure que le nombre de pannes augmentera.

   Summary

   La fonctionnalité coroutine de Swoole offre un moyen plus pratique, rapide et efficace pour le traitement des e-mails à haute concurrence. En pratique, il suffit de quelques lignes de code simples pour obtenir un traitement simultané élevé des e-mails en utilisant la fonctionnalité coroutine de Swoole. Si vous souhaitez développer d'autres applications à haute concurrence, vous pouvez également envisager d'utiliser la fonctionnalité coroutine de Swoole et essayer de l'intégrer dans votre projet pour améliorer les performances de l'application.

   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!