Swoole praktische Erfahrung: Verwendung von Coroutinen für die E-Mail-Verarbeitung mit hoher Parallelität

Mit der rasanten Entwicklung der Internet-Technologie und der kontinuierlichen Erweiterung der Anwendungsszenarien sind E-Mail-Dienste zu einem unverzichtbaren Bestandteil der täglichen Arbeit von Unternehmen/Einzelpersonen geworden. Beim E-Mail-Versand in großem Umfang wird jedoch eine hohe Parallelität häufig zu einem Engpass, z. B. häufige Verbindungen oder erneute Verbindungen zum SMTP-Server, Verbrauch der Nachrichtenwarteschlange und andere Vorgänge. Diese Vorgänge erfordern viel Zeit und Systemressourcen und wirken sich auf den gesamten E-Mail-Versand aus . Prozesseffizienz. Wie erreicht man also eine effiziente E-Mail-Verarbeitung mit minimalen Ressourcen?

Die Praxis zeigt, dass die Verwendung von Coroutinen für die E-Mail-Verarbeitung mit hoher Parallelität in Swoole eine sehr praktikable und effiziente Methode ist. In diesem Artikel werden einige Entwicklungspraktiken zur Verwendung der Coroutine-Funktion von Swoole vorgestellt, um eine hohe gleichzeitige E-Mail-Verarbeitung zu erreichen.

1. Einführung in Coroutinen

Coroutinen sind leichtgewichtige Threads, die als Kompromiss zwischen Prozessen und Threads angesehen werden können. Coroutinen haben die folgenden Eigenschaften:

1. Kostengünstiger Kontextwechsel
2. Kein Sperrmechanismus erforderlich
3. Leichte Belegung von Ressourcen
4. Zusammenarbeit bei mehreren Aufgaben

Mit der Coroutine-Funktion von Swoole können Sie Coroutinen über die folgenden Funktionen ausführen :

1. SwooleCoroutineun(callable $fn): Starten Sie eine Swoole-Coroutine.
2. SwooleCoroutinecreate(callable $fn, bool $coroutine_params): Erstelle eine Coroutine.
3. SwooleCoroutine::yield(): Unterbricht die Ausführung der aktuellen Coroutine und gibt keine CPU-Ressourcen frei.
4. SwooleCoroutine::resume($coroutine_id): Setzt die angegebene Coroutine fort.

2. Übung: Verwenden Sie die Coroutine-Funktion von Swool, um eine hohe gleichzeitige E-Mail-Verarbeitung zu erreichen.

1. Initialisieren Sie den SMTP-Client.

Die Verwendung der Coroutine-Funktion von Swool zum Verarbeiten von E-Mails ist recht einfach. Wir können E-Mails basierend auf der PHPMailer-Bibliothek versenden.

Zuerst müssen Sie den SMTP-Client initialisieren und die Parameter für den SMTP-Server festlegen:

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;
}

2. Verwenden Sie Coroutinen, um E-Mails mit hoher Parallelität zu senden

Als nächstes verwenden wir die Coroutine-Funktion von Swoole, um mehrere E-Mails gleichzeitig zu senden:

$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);

In diesem Beispiel verwenden wir die Funktion SwooleCoroutine::create(), um mehrere Coroutinen zu erstellen. Diese Coroutinen versenden mehrere E-Mails gleichzeitig. Schließlich verwenden wir die Funktion SwooleCoroutine::wait(), um zu warten, bis alle Coroutinen die Ausführung abgeschlossen haben.

3. Implementierung der SMTP-Serverstatuswartung

Wenn der SMTP-Server eine große Anzahl von Verbindungsanfragen empfängt, kann es sein, dass er die meisten Anfragen in kurzer Zeit ablehnt. Zu diesem Zeitpunkt müssen wir die Wartung des SMTP abschließen Serverstatus bei der Coroutine-Verarbeitung. Wenn der SMTP-Server beispielsweise die Anfrage ablehnt, müssen wir eine gewisse Zeit warten, bevor wir erneut versuchen, die E-Mail zu senden. Zu diesem Zeitpunkt müssen wir die Funktion SwooleCoroutinesleep() verwenden, um dies zu erreichen.

Zum Beispiel können wir den folgenden Code verwenden, um den Status des SMTP-Servers aufrechtzuerhalten:

$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!
";
           }
       }
   });
}

In diesem Beispielcode versuchen wir erneut, E-Mails zu senden und gehen jedes Mal, wenn es fehlschlägt, für eine gewisse Zeit in den Ruhezustand. Mit zunehmender Anzahl von Ausfällen erhöht sich jede Ruhezeit.

Zusammenfassung

Swooles Coroutine-Funktion bietet eine bequemere, schnellere und effizientere Möglichkeit für die E-Mail-Verarbeitung mit hoher Parallelität. In der Praxis sind nur wenige einfache Codezeilen erforderlich, um mithilfe der Coroutine-Funktion von Swoole eine hohe gleichzeitige E-Mail-Verarbeitung zu erreichen. Wenn Sie andere Anwendungen mit hoher Parallelität entwickeln möchten, können Sie auch die Coroutine-Funktion von Swoole in Betracht ziehen und versuchen, sie in Ihr Projekt zu integrieren, um die Anwendungsleistung zu verbessern.

Das obige ist der detaillierte Inhalt vonSwoole praktische Erfahrung: Verwendung von Coroutinen für die E-Mail-Verarbeitung mit hoher Parallelität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!