Swoole in Aktion: So verwenden Sie Coroutinen für Caching-Vorgänge

Swoole wurde in den letzten Jahren als leistungsstarkes asynchrones Netzwerk-Framework von Entwicklern bevorzugt und in verschiedenen Bereichen weit verbreitet eingesetzt. Coroutinen sind eines der sehr wichtigen Konzepte bei der Verwendung von Swoole, die es uns ermöglichen, asynchronen Code synchron zu schreiben. In diesem Artikel wird die Verwendung von Coroutinen für Caching-Vorgänge in Swoole vorgestellt und praktische Codebeispiele bereitgestellt.

1. Was ist eine Coroutine? In Swoole können Coroutinen zur Lösung von E/A-intensiven Netzwerkbetriebsproblemen wie Datenbankverbindungen, Redis-Vorgängen usw. verwendet werden. Die Coroutine kann die Kontrolle aktiv abgeben, wenn sie auf einen E/A-Vorgang trifft, und auf den Abschluss des Vorgangs warten, bevor sie mit der Ausführung fortfährt.

2. Swooles Coroutine-Unterstützung

Swoole hat seit Version 1.8.0 Coroutine-Unterstützung eingeführt, die eine Reihe von APIs zur Implementierung der Coroutine-Planung bereitstellt, einschließlich Coroutine, Go, Defer, Channel usw.

1. Coroutine

Coroutine ist die Grundoperation von Coroutine. Sie ermöglicht es uns, eine Funktion in eine Coroutine umzuwandeln, zum Beispiel:

function test()
{
    echo "start
";
    Coroutine::sleep(1);
    echo "end
";
}

Coroutine::create('test');
echo "hello
";

In diesem Beispiel konvertieren wir die Testfunktion in eine Coroutine und verwenden Coroutine::create (), um eine Coroutine zu erstellen. In der Coroutine verwenden wir Coroutine::sleep(), um eine E/A-Operation zu simulieren. Diese Operation führt dazu, dass die Coroutine eine Sekunde lang anhält, dann fortfährt und weiterhin „Ende“ ausgibt. Abschließend wird „Hallo“ ausgegeben, was die asynchrone Natur der Coroutine demonstriert.

2. go

go ist eine spezielle Funktion, die es uns ermöglicht, eine Funktion als Coroutine auszuführen, zum Beispiel:

go(function(){
    echo "hello
";
    Coroutine::sleep(1);
    echo "world
";
});
echo "start
";

In diesem Beispiel verwenden wir go(), um eine anonyme Funktion auszuführen. In der Funktion geben wir nacheinander „Hallo“ aus, halten eine Sekunde inne und geben dann „Welt“ aus. Schließlich wird „start“ ausgegeben, was beweist, dass wir Coroutinen verwenden, um diese Funktion gleichzeitig auszuführen.

3. defer

defer ermöglicht es uns, am Ende der Coroutine einige Aufräumarbeiten durchzuführen, z. B. das Schließen von Datenbankverbindungen, das Freigeben von Ressourcen usw. Die Verwendung ist wie folgt:

go(function(){
    $db = new Redis();
    $db->connect('127.0.0.1', 6379);
    defer(function() use ($db) {
        $db->close();
    });

    $db->set('key', 'value');
    Coroutine::sleep(1);
    $value = $db->get('key');
    echo $value."
";
});

In diesem Beispiel verwenden wir defer at Das Ende der Coroutine Die Redis-Verbindung wird geschlossen. Wenn wir defer nicht verwenden, vergessen wir möglicherweise, die Verbindung zu schließen, wenn die Coroutine endet, was dazu führt, dass die Anzahl der Verbindungen verloren geht.

4. Channel

channel ist ein von Swoole bereitgestellter Pipe-ähnlicher Mechanismus, der die Kommunikation zwischen mehreren Coroutinen ermöglicht, wie zum Beispiel:

$chan = new CoroutineChannel(1);

go(function() use($chan) {
    $data = Coroutine::getuid();
    $chan->push($data);
});

$data = $chan->pop();
echo $data."
";

In diesem Beispiel haben wir einen Kanal mit einer Kapazität von 1 erstellt und dann ein Stück davon verschoben Daten in den Kanal in einer Coroutine übertragen und die Daten in den Kanal in einer anderen Coroutine einfügen und ausgeben. Durch die Verwendung von Kanälen können wir Daten zwischen Coroutinen übertragen und die gemeinsame Aufgabenverarbeitung abschließen.

3. Coroutine-Operationscache

In der tatsächlichen Entwicklung ist der Cache eine sehr wichtige Komponente. Er kann den Datenbankdruck verringern und das Lesen von Daten durch Cache-Treffer beschleunigen. In Swoole können wir In-Memory-Datenbanken wie Redis verwenden, um Caching zu implementieren, und gleichzeitig können wir Coroutinen verwenden, um die Parallelitätsleistung des Caches zu verbessern.

1. Mit Redis verbinden

Wir verwenden den Coroutine-Redis-Client von Swoole, um eine Verbindung zur Redis-Datenbank herzustellen und gleichzeitig Vorgänge auszuführen:

$redis = new SwooleCoroutineRedis();
$redis->connect('127.0.0.1', 6379);

go(function () use ($redis) {
    $redis->set('name', 'Bob');
    $name = $redis->get('name');
    echo "name=$name
";
});

go(function () use ($redis) {
    $redis->set('age', 18);
    $age = $redis->get('age');
    echo "age=$age
";
});

SwooleCoroutine::sleep(1);

In diesem Beispiel verwenden wir den Coroutine-Redis-Client von Swoole, um eine Verbindung zur Redis-Datenbank herzustellen. Anschließend führten wir Lese- und Schreiboperationen in Form von Coroutinen durch und gaben die relevanten Ergebnisse innerhalb der Coroutinen aus. Verwenden Sie abschließend SwooleCoroutine::sleep(), um eine gewisse Zeit zu warten, um sicherzustellen, dass die Coroutine abgeschlossen ist. Auf ähnliche Weise können Sie eine Verbindung zu anderen In-Memory-Datenbanken herstellen und diese betreiben.

2. Betriebscache

Nachdem wir eine Verbindung zu Redis hergestellt haben, können wir eine Reihe von Cache-Befehlen für den Betrieb verwenden. Um beispielsweise zwischengespeicherte Daten festzulegen, können Sie die Methode set() verwenden:

$redis->set('key', 'value');

wobei „key“ der Schlüssel der zwischengespeicherten Daten und „value“ der Wert der zwischengespeicherten Daten ist. Um zwischengespeicherte Daten zu lesen, können Sie die Methode get() verwenden:

$value = $redis->get('key');

In der Coroutine können wir die oben genannten Befehle verwenden, um gleichzeitig zu arbeiten. Zum Beispiel:

go(function() use($redis){
    $redis->set('key1', 'value1');
    $value1 = $redis->get('key1');
    echo "key1=$value1
";
});

go(function() use($redis){
    $redis->set('key2', 'value2');
    $value2 = $redis->get('key2');
    echo "key2=$value2
";
});

SwooleCoroutine::sleep(1);

In diesem Beispiel haben wir zwei zwischengespeicherte Daten in zwei Coroutinen festgelegt und gelesen und sie dann gleichzeitig verarbeitet. Dies beweist, dass Coroutinen die Parallelitätsleistung zwischengespeicherter Daten verbessern können.

3. Operationscache und MySQL

In praktischen Anwendungen müssen wir normalerweise Cache und MySQL für Operationen kombinieren, z. B. zuerst Daten aus dem Cache lesen und, wenn kein Cache vorhanden ist, aus MySQL lesen. In der Coroutine-Entwicklung von Swoole können wir eine Methode ähnlich der folgenden verwenden, um diese Operation zu implementieren:

$redis = new SwooleCoroutineRedis();
$redis->connect('127.0.0.1', 6379);

$mysql = new SwooleCoroutineMySQL();
$mysql->connect([
    'host' => '127.0.0.1',
    'port' => 3306,
    'user' => 'root',
    'password' => '123456',
    'database' => 'test',
]);

go(function() use($redis, $mysql) {
    $name = $redis->get('name');
    if($name === false) {
        $result = $mysql->query('select * from user where id=1');
        if(!empty($result)) {
            $name = $result[0]['name'];
            $redis->set('name', $name);
        }
    }
    echo "name=$name
";
});

go(function() use($redis, $mysql) {
    $age = $redis->get('age');
    if($age === false) {
        $result = $mysql->query('select * from user where id=1');
        if(!empty($result)) {
            $age = $result[0]['age'];
            $redis->set('age', $age);
        }
    }
    echo "age=$age
";
});

SwooleCoroutine::sleep(1);

In diesem Beispiel verwenden wir die Coroutine-Operationsmethode. Versuchen Sie zunächst, Daten aus dem Cache zu lesen, wenn sie sich nicht im Cache befinden , die Daten werden aus MySQL gelesen. Beim Betrieb von MySQL verwenden wir auch Coroutinen, um das Blockieren von Threads zu vermeiden und die Effizienz zu verbessern. Abschließend haben wir die Leseergebnisse ausgedruckt, um die Richtigkeit dieser Operationsmethode zu beweisen.

Das Obige ist die spezifische Implementierung der Verwendung von Coroutinen für Cache-Operationen in Swoole. Coroutinen können die Effizienz und Parallelitätsleistung von Cache-Operationen verbessern und mit anderen Operationen wie MySQL kombiniert werden. In der tatsächlichen Entwicklung können wir auf die oben beschriebene Weise üben und Anpassungen und Änderungen entsprechend der tatsächlichen Situation vornehmen.

Das obige ist der detaillierte Inhalt vonSwoole in Aktion: So verwenden Sie Coroutinen für Caching-Vorgänge. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!