Swool dalam tindakan: Cara menggunakan coroutine untuk operasi caching

Dalam beberapa tahun kebelakangan ini, Swoole, sebagai rangka kerja rangkaian tak segerak berprestasi tinggi, telah digemari oleh pembangun dan digunakan secara meluas dalam pelbagai bidang. Dalam proses menggunakan Swoole, coroutine ialah salah satu konsep yang sangat penting, yang membolehkan kami menulis kod tak segerak secara segerak. Artikel ini akan memperkenalkan cara menggunakan coroutine untuk operasi caching dalam Swoole dan memberikan contoh kod praktikal.

1. Apakah coroutine? Coroutine ialah utas ringan dalam mod pengguna Ia diuruskan oleh pengaturcara melalui kod, mengelakkan penggunaan dan penukaran utas sistem. Dalam Swoole, coroutine boleh digunakan untuk menyelesaikan masalah operasi rangkaian intensif I/O, seperti sambungan pangkalan data, operasi Redis, dsb. Coroutine secara proaktif boleh melepaskan kawalan apabila menghadapi operasi I/O dan menunggu operasi selesai sebelum meneruskan pelaksanaan.

2. Sokongan coroutine Swoole

Swoole telah memperkenalkan sokongan coroutine sejak versi 1.8.0, yang menyediakan satu siri API untuk melaksanakan penjadualan coroutine, termasuk coroutine, go, defer, channel, dsb.

1. Coroutine

Coroutine ialah operasi asas coroutine Ia membolehkan kita menukar fungsi kepada coroutine, contohnya:

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

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

Dalam contoh ini, kita menukar fungsi ujian menjadi coroutine dan menggunakan Coroutine::create. () untuk mencipta coroutine. Dalam coroutine, kami menggunakan Coroutine::sleep() untuk mensimulasikan operasi I/O Operasi ini akan menyebabkan coroutine berhenti seketika selama 1 saat, kemudian menyambung semula dan terus mengeluarkan "tamat". Akhir sekali, "hello" ialah output, yang menunjukkan sifat tak segerak coroutine.

2. go

go ialah fungsi khas yang membolehkan kita menjalankan fungsi sebagai coroutine, contohnya:

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

Dalam contoh ini, kita menggunakan go() untuk menjalankan fungsi tanpa nama. Dalam fungsi tersebut, kami mengeluarkan "hello", jeda selama 1 saat, dan mengeluarkan "dunia" dalam urutan. Akhir sekali, "mula" ialah output, yang membuktikan bahawa kami menggunakan coroutine untuk menjalankan fungsi ini secara serentak. . hujung coroutine Sambungan Redis ditutup. Jika kita tidak menggunakan penangguhan, kita mungkin terlupa untuk menutup sambungan apabila coroutine tamat, menyebabkan bilangan sambungan bocor.

4 Saluran

saluran ialah mekanisme seperti paip yang disediakan oleh Swoole, yang membolehkan komunikasi antara berbilang coroutine, seperti:

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

Dalam contoh ini, kami mencipta saluran dengan kapasiti 1 , kemudian menolak sekeping data ke saluran dalam coroutine, dan pop data dalam saluran dalam coroutine lain dan keluarkannya. Menggunakan saluran membolehkan kami memindahkan data antara coroutine dan menyelesaikan pemprosesan tugas kolaboratif.

3. Cache operasi Coroutine

Dalam pembangunan sebenar, cache ialah komponen yang sangat penting Ia boleh mengurangkan tekanan pangkalan data dan mempercepatkan pembacaan data melalui capaian cache. Dalam Swoole, kita boleh menggunakan pangkalan data dalam memori seperti Redis untuk melaksanakan caching, dan pada masa yang sama, kita boleh menggunakan coroutine untuk meningkatkan prestasi konkurensi cache.

1. Sambung ke Redis

Kami menggunakan klien Redis coroutine Swoole untuk menyambung ke pangkalan data Redis dan beroperasi serentak Kodnya adalah seperti berikut:

$chan = new CoroutineChannel(1);

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

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

Dalam contoh ini, kami menggunakan klien Redis coroutine Swoole untuk menyambungkan pangkalan data Redis. Kemudian kami melakukan operasi membaca dan menulis dalam bentuk coroutine, dan mengeluarkan hasil yang berkaitan dalam coroutine. Akhir sekali, gunakan SwooleCoroutine::sleep() untuk menunggu tempoh masa bagi memastikan coroutine selesai. Anda boleh menyambung dan mengendalikan pangkalan data dalam memori lain dengan cara yang sama.

2. Cache operasi

Selepas menyambung ke Redis, kita boleh menggunakan satu siri arahan cache untuk beroperasi. Sebagai contoh, untuk menetapkan data cache, anda boleh menggunakan kaedah set():

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

di mana 'kunci' ialah kunci data cache dan 'nilai' ialah nilai data cache. Untuk membaca data cache, anda boleh menggunakan kaedah get():

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

Dalam coroutine, kita boleh menggunakan arahan di atas untuk beroperasi secara serentak. Contohnya:

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

Dalam contoh ini, kami menetapkan dan membaca dua data cache masing-masing dalam dua coroutine, dan kemudian mengendalikannya secara serentak. Ini membuktikan bahawa coroutine boleh meningkatkan prestasi serentak data cache.

3. Operation cache dan MySQL

Dalam aplikasi praktikal, kita biasanya perlu menggabungkan cache dan MySQL untuk operasi, seperti membaca data dari cache terlebih dahulu, dan jika tiada cache, baca dari MySQL. Dalam pembangunan coroutine Swoole, kita boleh menggunakan kaedah yang serupa dengan yang berikut untuk melaksanakan operasi ini:

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

Dalam contoh ini, kita menggunakan kaedah operasi coroutine, mula-mula cuba baca data daripada cache, jika Jika ia tiada dalam cache , data dibaca daripada MySQL. Semasa mengendalikan MySQL, kami juga menggunakan coroutine untuk mengelak daripada menyekat benang dan meningkatkan kecekapan. Akhirnya, kami mencetak hasil bacaan untuk membuktikan ketepatan kaedah operasi ini.

Di atas ialah kaedah pelaksanaan khusus menggunakan coroutine untuk operasi cache dalam Swoole dapat meningkatkan kecekapan dan prestasi penyelarasan operasi cache, dan boleh digabungkan dengan operasi lain seperti MySQL. Dalam pembangunan sebenar, kita boleh mengamalkan cara di atas dan membuat pelarasan dan perubahan mengikut situasi sebenar.

Atas ialah kandungan terperinci Swool dalam tindakan: Cara menggunakan coroutine untuk operasi caching. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!