Pengaturcaraan selari dengan pthreads dalam php - fundamental

mata utama

• Elakkan menggunakan PTHREADS dalam persekitaran pelayan web: Oleh kerana isu keselamatan dan skalabiliti, PTHREADS tidak boleh digunakan dalam persekitaran pelayan web seperti FCGI, kerana ia tidak dapat mengendalikan pelbagai persekitaran yang berkesan dalam thread persekitaran ini.
• Gunakan PTHREADS untuk tugas satu kali atau operasi mengikat IO: untuk tugas yang melaksanakan satu atau memerlukan sejumlah besar operasi IO, menggunakan PTHREADS dapat membantu menyahpasang benang pelaksanaan utama dan mengendalikannya dalam berasingan Thread Operasi ini digunakan untuk meningkatkan prestasi.
• Benang kitar semula untuk mengoptimumkan sumber: Mewujudkan thread baru untuk setiap tugas boleh mengambil banyak sumber;
• Memahami invarians pthreads dan kelas yang tidak menentu: Secara lalai, sifat -sifat objek yang diperluas tidak dapat dielakkan untuk mengelakkan kemerosotan prestasi, dan kelas yang tidak menentu menyediakan cara untuk menguruskan mutabel apabila perlu atribut.
• Melaksanakan penyegerakan untuk keselamatan benang: Untuk mengelakkan rasuah data dan memastikan hasil yang konsisten apabila pelbagai benang mengakses sumber yang dikongsi bersama, gunakan kaedah penyegerakan yang disediakan oleh PTHREADS, seperti blok penyegerakan dan berulir :: Tunggu dan diulurkan: : Beritahu dan kaedah lain.

Artikel ini dikaji semula oleh Christopher Pitt. Terima kasih kepada semua pengulas rakan sebaya untuk membuat kandungan SitePoint sempurna!

---

pemaju PHP nampaknya jarang mengambil kesempatan daripada paralelisme. Kesederhanaan pengaturcaraan segerak, tunggal yang sangat menarik, tetapi kadang-kadang menggunakan keseragaman sedikit boleh membawa kepada peningkatan prestasi yang berbaloi.

Dalam artikel ini, kita akan belajar bagaimana untuk melaksanakan benang dalam PHP menggunakan lanjutan PTHREADS. Ini memerlukan pemasangan versi ZTS (Zend Thread-Safe) Php 7.x, serta pemasangan PTHREADS V3. .

Penjelasan cepat: PTHREADS v2 ditujukan kepada Php 5.x, tidak lagi disokong;

Terima kasih banyak kepada Joe Watkins (Pencipta Extension PTHREADS) untuk membuktikan pembacaan dan membantu memperbaiki jawatan saya!

apabila tidak menggunakan pthreads

Sebelum kita meneruskan, saya ingin terlebih dahulu menerangkan keadaan di mana anda tidak boleh

(dan

tidak boleh

) menggunakan lanjutan PTHREADS. Dalam PTHREADS V2, tidak disyorkan untuk menggunakan PTHREADS dalam persekitaran pelayan web (iaitu, dalam proses FCGI). Bermula dengan PTHREADS V3, cadangan ini dikuatkuasakan, jadi anda tidak boleh menggunakannya dalam persekitaran pelayan web sama sekali. Dua sebab utama untuk melakukan ini adalah:

1. Tidak selamat menggunakan pelbagai benang dalam persekitaran ini (yang boleh menyebabkan isu IO dan isu -isu lain).
2. Ia tidak skala dengan baik. Sebagai contoh, katakan anda mempunyai skrip PHP yang mencipta benang baru untuk mengendalikan beberapa kerja, dan skrip itu dijalankan setiap kali anda memintanya. Ini bermakna untuk setiap permintaan, aplikasi anda mencipta benang baru (ini adalah model thread 1: 1 - satu benang sepadan dengan satu permintaan). Jika permohonan anda memproses 1,000 permintaan sesaat, ia mewujudkan 1,000 benang sesaat! Menjalankan begitu banyak benang pada mesin tunggal dengan cepat akan mengatasinya, dan masalah ini hanya akan memburukkan lagi apabila kadar permintaan meningkat.

inilah sebabnya benang bukan penyelesaian yang baik dalam persekitaran ini. Sekiranya anda mencari penyelesaian untuk benang sebagai tugas menghalang IO (seperti melakukan permintaan HTTP), maka saya akan menunjukkan arah pengaturcaraan

kembali ke titik, mari kita terus ke topik!

Latihan Tugas Satu Masa

Kadang-kadang anda ingin mengendalikan tugas satu kali dengan cara yang berbilang threaded (seperti melaksanakan beberapa tugas IO-terikat). Dalam kes ini, anda boleh menggunakan kelas thread untuk membuat benang baru dan menjalankan beberapa unit kerja dalam benang yang berasingan.

Contoh:

di atas, kaedah larian adalah unit kerja yang akan kita laksanakan dalam benang baru. Apabila Thread :: Start dipanggil, benang baru dihasilkan dan kaedah larian dipanggil. Kami kemudian menyertai semula benang yang dihasilkan ke benang utama (melalui thread :: gabungan), yang akan menyekat sehingga benang individu melengkapkan pelaksanaan. Ini memastikan bahawa tugas itu telah menyelesaikan pelaksanaan sebelum cuba mengeluarkan hasilnya (disimpan dalam $ tugas- & gt; respons).

$task = new class extends Thread {
    private $response;

    public function run()
    {
        $content = file_get_contents("http://google.com");
        preg_match("~<title>(.+)</title>~", $content, $matches);
        $this->response = $matches[1];
    }
};

$task->start() && $task->join();

var_dump($task->response); // string(6) "Google"

Tanggungjawab mencemari kelas dengan logik yang berkaitan dengan benang (termasuk perlu menentukan kaedah larian) mungkin tidak sesuai. Kita boleh mengasingkan kelas -kelas ini dengan memajukan mereka kelas berulir, dan kemudian menjalankannya dalam benang lain:

Mana -mana kelas yang perlu dijalankan dalam benang yang berasingan akan

class Task extends Threaded
{
    public $response;

    public function someWork()
    {
        $content = file_get_contents('http://google.com');
        preg_match('~<title>(.+)</title>~', $content, $matches);
        $this->response = $matches[1];
    }
}

$task = new Task;

$thread = new class($task) extends Thread {
    private $task;

    public function __construct(Threaded $task)
    {
        $this->task = $task;
    }

    public function run()
    {
        $this->task->someWork();
    }
};

$thread->start() && $thread->join();

var_dump($task->response);

mesti melanjutkan kelas berulir dalam beberapa cara. Ini kerana ia menyediakan keupayaan yang diperlukan untuk dijalankan dalam benang yang berbeza, serta menyediakan keselamatan tersirat dan antara muka yang berguna (untuk penyegerakan sumber, dll.).

mari kita cepat memahami hierarki kelas yang terdedah oleh pthreads:

Kami telah mempelajari asas -asas benang dan kelas berulir, jadi mari kita lihat tiga baki (pekerja, tidak menentu, dan kolam).

Thread Recycle

Adalah mahal untuk memulakan benang baru untuk setiap tugas untuk dipasangkan. Ini kerana untuk melaksanakan benang di dalam PHP, PTHREADS mesti mengadopsi seni bina tanpa stateless bersama. Ini bermakna bahawa keseluruhan konteks pelaksanaan (termasuk setiap kelas, antara muka, atribut, dan fungsi) contoh semasa penterjemah PHP mesti disalin untuk setiap benang yang dibuat. Oleh kerana ini boleh memberi kesan prestasi yang signifikan, benang harus selalu digunakan semula sebanyak mungkin. Terdapat dua cara untuk menggunakan semula benang: menggunakan pekerja atau menggunakan kolam.

Kelas Pekerja digunakan untuk melaksanakan satu siri tugas serentak dalam benang lain. Ini dilakukan dengan membuat contoh pekerja baru (ini akan mewujudkan benang baru) dan kemudian menyusun tugas ke benang yang berasingan (melalui pekerja :: stack).

ini adalah contoh mudah:

$task = new class extends Thread {
    private $response;

    public function run()
    {
        $content = file_get_contents("http://google.com");
        preg_match("~<title>(.+)</title>~", $content, $matches);
        $this->response = $matches[1];
    }
};

$task->start() && $task->join();

var_dump($task->response); // string(6) "Google"

output:

Tumpuan di atas 15 tugas ke objek pekerja $ baru melalui pekerja :: stack dan kemudian memprosesnya dalam susunan susunan. Seperti yang ditunjukkan di atas, Kaedah Pekerja :: Koleksi digunakan untuk membersihkan tugas selepas tugas telah menyelesaikan pelaksanaan. Dengan menggunakannya dalam gelung sementara, kami menyekat benang utama sehingga semua tugas yang disusun telah dilaksanakan dan telah dibersihkan, dan kemudian kami mencetuskan pekerja :: shutdown. Menutup pekerja lebih awal (iaitu, sementara tugas masih perlu dilaksanakan) masih akan menyekat benang utama sehingga semua tugas selesai dilaksanakan - tugas tidak akan dikumpulkan sampah (menyebabkan kebocoran memori).

Kelas pekerja menyediakan beberapa kaedah yang berkaitan dengan tumpuan tugas, termasuk pekerja :: Unstack untuk memadam item timbunan tertua, dan pekerja :: GetStacked untuk melaksanakan bilangan item di timbunan. Tumpukan pekerja hanya menyelamatkan tugas -tugas yang akan dilaksanakan. Sebaik sahaja tugas dalam timbunan dilaksanakan, ia dipadamkan dan diletakkan pada timbunan lain (dalaman) untuk pengumpulan sampah (menggunakan pekerja :: mengumpul).

Cara lain untuk menggunakan semula benang apabila melaksanakan banyak tugas ialah menggunakan kolam thread (melalui kelas kolam). Kolam thread didorong oleh satu set pekerja untuk membolehkan tugas -tugas dilaksanakan secara serentak, di mana faktor konkurensi (bilangan benang yang dijalankan kolam) ditentukan pada masa penciptaan kolam.

mari menyesuaikan contoh di atas untuk menggunakan kolam pekerja:

output:

class Task extends Threaded
{
    public $response;

    public function someWork()
    {
        $content = file_get_contents('http://google.com');
        preg_match('~<title>(.+)</title>~', $content, $matches);
        $this->response = $matches[1];
    }
}

$task = new Task;

$thread = new class($task) extends Thread {
    private $task;

    public function __construct(Threaded $task)
    {
        $this->task = $task;
    }

    public function run()
    {
        $this->task->someWork();
    }
};

$thread->start() && $thread->join();

var_dump($task->response);

Terdapat beberapa perbezaan yang signifikan antara menggunakan kolam dan menggunakan program pekerja. Pertama, kolam tidak perlu dimulakan secara manual, mereka mula melaksanakan tugas sebaik sahaja ia tersedia. Kedua, kami menyerahkan tugas -tugas

ke kolam dan bukannya menyusunnya. Di samping itu, kelas kolam tidak dilanjutkan, jadi ia tidak boleh diluluskan ke benang lain (tidak seperti pekerja).

Sebagai amalan yang baik, anda harus sentiasa mengumpul tugas untuk program dan kolam pekerja selepas menyelesaikan tugas dan menutupnya secara manual. Benang yang dibuat melalui kelas benang juga harus disambungkan semula ke benang pencipta.

pthreads dan (bukan) variabiliti

Kelas terakhir yang diperkenalkan adalah tidak menentu -tambahan baru kepada PTHREADS v3. Invariance telah menjadi satu konsep penting dalam pthreads kerana tanpa itu, prestasi akan teruk terdegradasi. Oleh itu, secara lalai, sifat -sifat kelas berulir yang sendiri objek berulir kini tidak berubah dan oleh itu tidak dapat ditugaskan semula selepas tugasan awal. Kini lebih cenderung untuk secara jelas bermutasi sifat -sifat ini, dan ia masih boleh dilakukan dengan menggunakan kelas yang tidak menentu baru.

mari kita lihat dengan cepat contoh untuk menunjukkan kekangan invarians baru:

$task = new class extends Thread {
    private $response;

    public function run()
    {
        $content = file_get_contents("http://google.com");
        preg_match("~<title>(.+)</title>~", $content, $matches);
        $this->response = $matches[1];
    }
};

$task->start() && $task->join();

var_dump($task->response); // string(6) "Google"

Sebaliknya, harta yang berulir dari kelas yang tidak menentu boleh berubah:

class Task extends Threaded
{
    public $response;

    public function someWork()
    {
        $content = file_get_contents('http://google.com');
        preg_match('~<title>(.+)</title>~', $content, $matches);
        $this->response = $matches[1];
    }
}

$task = new Task;

$thread = new class($task) extends Thread {
    private $task;

    public function __construct(Threaded $task)
    {
        $this->task = $task;
    }

    public function run()
    {
        $this->task->someWork();
    }
};

$thread->start() && $thread->join();

var_dump($task->response);

kita dapat melihat bahawa kelas yang tidak menentu mengatasi invarians yang dikuatkuasakan oleh kelas berulir kelas induknya untuk membolehkan pengagihan semula (dan unsetting) harta berulir.

Mengenai variasi dan kelas yang tidak menentu, terdapat satu lagi topik asas terakhir yang perlu diperkenalkan - tatasusunan. Apabila array ditugaskan ke harta kelas berulir, array dalam pthreads secara automatik dilemparkan ke objek yang tidak menentu. Ini kerana ia tidak selamat untuk memanipulasi array dari pelbagai konteks dalam PHP.

mari kita lihat dengan cepat contoh sekali lagi untuk memahami dengan lebih baik:

<code>Threaded (implements Traversable, Collectable)
    Thread
        Worker
    Volatile
Pool</code>

kita dapat melihat bahawa objek yang tidak menentu boleh dirawat seperti tatasusunan, kerana mereka memberikan sokongan untuk pengendali subset ([]) untuk operasi berasaskan array (seperti yang ditunjukkan di atas). Walau bagaimanapun, kelas yang tidak menentu tidak disokong oleh fungsi berasaskan array biasa seperti array_pop dan array_shift. Sebaliknya, kelas berulir memberikan kami operasi ini sebagai kaedah terbina dalam.

sebagai demonstrasi:

class Task extends Threaded
{
    private $value;

    public function __construct(int $i)
    {
        $this->value = $i;
    }

    public function run()
    {
        usleep(250000);
        echo "Task: {$this->value}\n";
    }
}

$worker = new Worker();
$worker->start();

for ($i = 0; $i < 15; $i++) {
    $worker->stack(new Task($i));
}

while ($worker->collect());

$worker->shutdown();

Operasi yang disokong lain termasuk berulir :: bahagian dan berulir :: gabungan.

Penyegerakan

Topik terakhir yang akan diperkenalkan dalam artikel ini adalah penyegerakan dalam pthreads. Penyegerakan adalah teknologi yang membolehkan akses kawalan kepada sumber yang dikongsi.

Contohnya, mari kita melaksanakan kaunter yang mudah:

class Task extends Threaded
{
    private $value;

    public function __construct(int $i)
    {
        $this->value = $i;
    }

    public function run()
    {
        usleep(250000);
        echo "Task: {$this->value}\n";
    }
}

$pool = new Pool(4);

for ($i = 0; $i < 15; $i++) {
    $pool->submit(new Task($i));
}

while ($pool->collect());

$pool->shutdown();

Jika penyegerakan tidak digunakan, output tidak ditentukan. Pelbagai benang menulis kepada pembolehubah tunggal tanpa mengawal akses boleh menyebabkan kemas kini yang hilang.

mari kita membetulkan ini dengan menambahkan penyegerakan supaya kita mendapat output yang betul 20:

class Task extends Threaded // a Threaded class
{
    public function __construct()
    {
        $this->data = new Threaded();
        // $this->data is not overwritable, since it is a Threaded property of a Threaded class
    }
}

$task = new class(new Task()) extends Thread { // a Threaded class, since Thread extends Threaded
    public function __construct($tm)
    {
        $this->threadedMember = $tm;
        var_dump($this->threadedMember->data); // object(Threaded)#3 (0) {}
        $this->threadedMember = new StdClass(); // invalid, since the property is a Threaded member of a Threaded class
    }
};

blok kod penyegerakan juga boleh berfungsi dengan berulir :: tunggu dan berulir :: Beritahu (dan berulir :: notifyOne).

Berikut adalah kenaikan interleaved dari dua segerak manakala gelung:

class Task extends Volatile
{
    public function __construct()
    {
        $this->data = new Threaded();
        $this->data = new StdClass(); // valid, since we are in a volatile class
    }
}

$task = new class(new Task()) extends Thread {
    public function __construct($vm)
    {
        $this->volatileMember = $vm;

        var_dump($this->volatileMember->data); // object(stdClass)#4 (0) {}

        // still invalid, since Volatile extends Threaded, so the property is still a Threaded member of a Threaded class
        $this->volatileMember = new StdClass();
    }
};

anda mungkin menyedari bahawa keadaan tambahan ditambah di sekitar panggilan untuk berulir :: tunggu. Syarat -syarat ini adalah kritikal kerana mereka hanya membenarkan panggilan balik segerak untuk pulih apabila pemberitahuan

dan menyatakan bahawa keadaan itu benar. Ini penting kerana pemberitahuan boleh datang dari luar yang diulurkan :: Beritahu panggilan. Oleh itu, jika panggilan untuk berulir :: tunggu tidak termasuk dalam keadaan, kita akan terdedah kepada panggilan Wake-Up palsu , yang akan menyebabkan kod itu tidak dapat diramalkan.

Kesimpulan

Kami telah melihat lima kelas (thread, thread, pekerja, tidak menentu, dan kolam) yang datang dengan pthreads, termasuk memperkenalkan penggunaan setiap kelas. Kami juga melihat konsep baru invariance dalam pthreads, serta melihat dengan cepat ciri -ciri penyegerakan yang disokongnya. Dengan asas -asas ini, kita kini dapat melihat memohon pthreads untuk beberapa kes penggunaan praktikal! Ini akan menjadi subjek jawatan seterusnya kami.

Pada masa yang sama, jika anda mempunyai sebarang idea aplikasi untuk pthreads, jangan ragu untuk meninggalkan pemikiran anda di bahagian komen di bawah!

FAQs (FAQ) pada pengaturcaraan selari dengan pthreads dalam php

Apakah prasyarat untuk menggunakan pthreads dalam php?

Untuk menggunakan PTHREADS dalam PHP, anda perlu mempunyai pengetahuan tentang PHP dan pengaturcaraan berorientasikan objek. Anda juga perlu memasang ZTS (Zend Thread Safety) yang membolehkan PHP. PTHREADS tidak tersedia dalam pemasangan PHP standard; Anda boleh menyemak sama ada pemasangan PHP anda mempunyai ZTS didayakan dengan menjalankan perintah "php -i | grep" keselamatan benang "" di terminal. Jika ia mengembalikan "keselamatan thread = & gt; didayakan", maka anda boleh menggunakan pthreads.

bagaimana memasang pthreads dalam php?

Untuk memasang PTHREADS, anda perlu menggunakan PECL, iaitu Perpustakaan Komuniti PHP Extension. Pertama, pastikan anda mempunyai PHP yang diaktifkan ZTS. Kemudian, di terminal anda, jalankan perintah "PECL Pasang PTHREADS". Jika pemasangan berjaya, anda perlu menambah garis "Extension = pthreads.so" ke fail php.ini anda. Ini akan memuatkan sambungan PTHREADS setiap kali PHP dijalankan.

Bagaimana untuk membuat thread baru dalam php menggunakan pthreads?

Untuk membuat thread baru, anda perlu menentukan kelas yang memanjangkan kelas thread yang disediakan oleh PTHREADS. Dalam kelas ini, anda akan menimpa kaedah larian (), iaitu kod yang akan dilaksanakan dalam benang baru. Anda kemudian boleh membuat contoh kelas ini dan memanggil kaedah permulaannya () untuk memulakan benang baru.

Bagaimana menggunakan PTHREADS untuk berkongsi data antara benang dalam PHP?

PTHREADS menyediakan kelas berulir untuk berkongsi data antara benang. Anda boleh membuat contoh baru kelas ini dan lulus ke benang anda. Mana -mana sifat yang ditetapkan pada objek ini akan dikongsi dengan selamat di antara benang.

Bagaimana menangani kesilapan dalam pthreads?

Pengendalian ralat dalam PTHREADS adalah serupa dengan pengendalian ralat dalam php standard. Anda boleh menggunakan blok percubaan untuk menangkap pengecualian. Walau bagaimanapun, ambil perhatian bahawa setiap benang mempunyai skop sendiri, jadi pengecualian dalam satu benang tidak akan menjejaskan benang lain.

Bolehkah saya menggunakan PTHREADS dalam kerangka PHP seperti Laravel atau Symfony?

Pthreads tidak serasi dengan kerangka PHP seperti Laravel atau Symfony. Ini kerana rangka kerja ini tidak direka untuk menjadi benang. Sekiranya anda perlu melakukan pemprosesan selari dalam rangka kerja ini, pertimbangkan untuk menggunakan teknik lain seperti beratur atau tugas asynchronous.

bagaimana untuk debug skrip php menggunakan pthreads?

Debugging PHP Skrip Menggunakan PTHREADS boleh mencabar kerana setiap benang berjalan dalam konteksnya sendiri. Walau bagaimanapun, anda boleh menggunakan teknik debugging standard seperti rakaman atau mengeluarkan data ke konsol. Anda juga boleh menggunakan debuggers PHP seperti Xdebug, tetapi sedar bahawa tidak semua debuggers menyokong aplikasi multithreaded.

Bolehkah saya menggunakan pthreads dalam persekitaran pelayan web?

PTHREADS tidak disyorkan dalam persekitaran pelayan web. Ia direka untuk skrip CLI (Command Line Interface). Menggunakan pthreads dalam persekitaran pelayan web boleh membawa kepada hasil yang tidak dapat diramalkan dan sering tidak selamat.

bagaimana menggunakan pthreads untuk menghentikan benang berjalan di PHP?

Untuk menghentikan benang berjalan, anda boleh menggunakan kaedah Kill () yang disediakan oleh PTHREADS. Walau bagaimanapun, kaedah ini harus digunakan dengan berhati -hati, kerana ia boleh membawa kepada hasil yang tidak dapat diramalkan jika benang sedang beroperasi. Ia biasanya terbaik untuk merancang benang anda supaya mereka dapat menyelesaikan tugas mereka dengan bersih.

Adakah terdapat alternatif kepada pthreads untuk pengaturcaraan selari dalam PHP?

Ya, terdapat beberapa alternatif untuk pthreads untuk pengaturcaraan selari dalam PHP. Ini termasuk Forks, lanjutan PECL yang menyediakan antara muka untuk mewujudkan dan menguruskan proses kanak -kanak, dan selari, lanjutan PHP asli yang diperkenalkan dalam Php 7.2, yang menyediakan antara muka pengaturcaraan selari yang lebih mudah dan selamat.

Atas ialah kandungan terperinci Pengaturcaraan selari dengan pthreads dalam php - fundamental. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!