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

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.

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

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

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

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

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