Naif menunggu di dalam gelung di Async PHP menyebabkan pelaksanaan berurutan, mengalahkan kesesuaian; 2. Dalam amp, gunakan amp \ promise \ all () untuk menjalankan semua operasi selari dan tunggu untuk siap, atau amp \ iterator \ fromiteNable () untuk memproses hasil ketika mereka tiba; 3. Dalam ReactPhp, gunakan React \ Promise \ all () untuk pelaksanaan selari atau promisemap :: Map () dengan batas konvensional untuk mengawal operasi serentak; 4. Sentiasa mengelakkan menyekat gelung di dalam, mengendalikan kesilapan dengan kombinasi janji yang sesuai, menguruskan tekanan balik dengan hasil streaming, dan lebih suka menunggu keseluruhan operasi dan bukan tugas individu untuk mengekalkan prestasi dan aliran kawalan.

Apabila bekerja dengan kerangka PHP asynchronous seperti AMP atau ReactPHP , salah satu peralihan mental terbesar dari PHP tradisional adalah bagaimana anda mengendalikan gelung - terutamanya ketika berurusan dengan operasi tak segerak di dalamnya. Dalam PHP segerak, gelung foreach adalah mudah: jalankan beberapa kod untuk setiap item, satu demi satu. Tetapi dalam konteks async, naif menunggu di dalam gelung boleh membawa kepada kesesakan prestasi yang tidak dijangka atau aliran kawalan yang pecah.

Mari kita pecahkan cara mengendalikan lelaran tak segerak dalam amp dan ReactPhp, dan mengapa pendekatan biasa tidak selalu berfungsi.

Mengapa gelung biasa gagal dalam kod async

Dalam PHP segerak, anda mungkin menulis:

 foreach ($ url sebagai $ url) {
    $ result = file_get_contents ($ url);
    Echo $ Result;
}

Tetapi dalam kod async, jika anda mencuba ini:

 // Jangan buat ini
foreach ($ url sebagai $ url) {
    $ hasil = hasil $ httpclient-> permintaan ($ url); // amp
    Echo $ Result;
}

Anda sedang menunggu setiap permintaan secara berurutan - permintaan seterusnya tidak akan bermula sehingga selesai sebelumnya. Itu membunuh manfaat kesesuaian.

Lebih buruk lagi: Dalam ReactPhp , anda tidak boleh yield sama sekali, dan menyekat menunggu tidak dibenarkan. Anda perlu berantai then() panggilan balik - yang dengan cepat menjadi tidak dapat dikendalikan dalam gelung.

Mengendalikan lelaran async dalam amp

AMP menyediakan alat untuk menguruskan lelaran async dengan betul. Kuncinya adalah untuk mengelakkan yield di dalam badan gelung dan sebaliknya memulakan semua operasi serentak , kemudian tunggu mereka.

Gunakan Amp\Promise\all() untuk pelaksanaan selari

 Gunakan amp \ Promise;
Gunakan amp \ http \ client \ client;
Gunakan amp \ http \ client \ request;

$ janji = [];

foreach ($ url sebagai $ url) {
    $ janji [] = amp \ call (fn () => $ httpClient-> request ($ url)-> getBody ());
}

$ hasil = Janji hasil \ semua ($ janji);

foreach ($ hasil sebagai hasil $) {
    Echo $ Result;
}

Ini bermula semua permintaan HTTP selari , kemudian menunggu semua selesai.

? Terbaik untuk: Apabila anda mahu semua item diproses dan boleh menunggu yang paling lambat.

Gunakan Amp\Iterator untuk hasil aliran

Jika anda ingin memproses hasil ketika mereka tiba , gunakan Amp\ConcurrentIterator :

 $ janji = [];
foreach ($ url sebagai $ url) {
    $ janji [] = amp \ call (fn () => $ httpClient-> request ($ url)-> getBody ());
}

$ iterator = amp \ iterator \ fromiteNable ($ janji);

Semasa (hasil $ iterator-> Advance ()) {
    $ hasil = $ iterator-> getCurrent ();
    echo "got: $ result \ n";
}

Hasil output ini sebaik sahaja setiap janji menyelesaikan , tanpa menunggu semua.

Mengendalikan lelaran async dalam ReactPhp

ReactPhp menggunakan panggil balik dan React\Promise\PromiseInterface . Tidak ada yield , jadi anda membina rantai janji atau menggunakan fungsi utiliti.

Gunakan React\Promise\all() untuk pelaksanaan selari

 Gunakan React \ Promise;

$ janji = [];

foreach ($ url sebagai $ url) {
    $ janji [] = $ httpclient-> permintaan ('get', $ url)-> kemudian (
        FN ($ respons) => $ respons-> getBody ()-> getContents ()
    );
}

Janji \ semua ($ janji)-> kemudian (fungsi ($ hasil) {
    foreach ($ hasil sebagai hasil $) {
        Echo $ Result;
    }
});

Seperti AMP's all() , ini menjalankan segala -galanya selari dan menyelesaikan apabila semua selesai.

? Baik untuk pemprosesan batch, tetapi blok output sehingga item terakhir.

Gunakan React\Promise\some() atau map() untuk lebih banyak kawalan

Untuk pemprosesan dengan had (misalnya, max 3 serentak), gunakan clue/reactphp-mq atau react/promise-maps (pihak ketiga):

 Gunakan React \ Promise \ Promisemap;

$ hasil = promisemap :: peta ($ url, fungsi ($ url) penggunaan ($ httpclient) {
    kembali $ httpclient-> permintaan ('get', $ url)
        -> kemudian (fn ($ res) => $ res-> getBody ()-> getContents ());
}, ['concurrency' => 3]);

$ hasil-> kemudian (fungsi ($ badan) {
    foreach ($ badan sebagai $ body) {
        echo $ body;
    }
});

Ini menghadkan kesesuaian kepada 3 permintaan pada satu masa - sesuai untuk mengelakkan pelayan yang luar biasa.

Takeaways utama

• ? Jangan sekali -kali yield atau menyekat di dalam gelung yang mengharapkan kesesuaian.
• ? Gunakan Promise\all() apabila anda memerlukan semua hasil dan boleh menunggu.
• ? Gunakan Iterator Streaming (AMP) atau map() dengan had kesesuaian (ReactPhp) untuk kawalan aliran yang lebih baik.
• ? Hasil proses apabila mereka tiba apabila mungkin - meningkatkan respons.
• ?? Berhati -hati dengan ingatan: Buffering beribu -ribu janji boleh mahal.

Untuk kegunaan dunia nyata, pertimbangkan:

• Pengendalian ralat : Gunakan Promise\any() , some() , atau bungkus dalam try/catch (amp) atau .catch() (reactPhp).
• Backpressure : Hasil aliran dan bukannya mengumpul segala -galanya.
• Pembatalan : AMP menyokong janji yang boleh dibatalkan; ReactPhp kurang begitu.

Async lelaran bukan tentang menggantikan foreach - ia mengenai pemikiran semula kapan dan bagaimana anda menunggu.

Pada asasnya, jangan gelung untuk menunggu - menanti gelung.

Atas ialah kandungan terperinci Perulangan Asynchronous: Lihat gelung dalam konteks amp atau Reactphp. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!