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!