Meneroka Concurrency dan Paralelisme dalam PHP: Tutorial dan Petua Hands-On

Memahami konkurensi dan keselarian adalah penting untuk menulis aplikasi PHP yang cekap, terutamanya apabila berurusan dengan berbilang tugas atau operasi yang perlu dikendalikan secara serentak. Berikut ialah panduan langkah demi langkah untuk memahami dan melaksanakan keselarasan dan keselarian dalam PHP, dengan contoh dan penerangan langsung.

1. Keselarasan lwn. Paralelisme

• Concurrency: Merujuk kepada keupayaan sistem untuk mengendalikan berbilang tugasan serentak dengan menyelangi pelaksanaannya. Ini tidak semestinya bermakna tugasan dilaksanakan pada masa yang sama, cuma ia diuruskan supaya ia kelihatan berjalan serentak.

• Paralelisme: Melibatkan pelaksanaan berbilang tugas pada masa yang sama, memanfaatkan berbilang pemproses atau teras. Ini ialah subset konkurensi yang mana tugasan dijalankan secara selari.

2. Concurrency dalam PHP

PHP secara tradisinya adalah satu benang, bermakna ia mengendalikan satu tugas pada satu masa. Walau bagaimanapun, keselarasan masih boleh dicapai melalui teknik seperti pemprosesan tak segerak dan menggunakan alat luaran.

2.1. Menggunakan pcntl_fork untuk Concurrency

Pelanjutan pcntl (Kawalan Proses) dalam PHP membenarkan kawalan proses dan boleh digunakan untuk mencapai konkurensi dengan memotong proses.

Prasyarat:

• Pastikan sambungan pcntl didayakan dalam pemasangan PHP anda.

Contoh:

<?php
// Check if pcntl is available
if (!function_exists('pcntl_fork')) {
    die('The pcntl extension is not available.');
}

$pid = pcntl_fork();

if ($pid == -1) {
    // Fork failed
    die('Could not fork');
} elseif ($pid) {
    // Parent process
    echo "Parent Process\n";
    pcntl_wait($status); // Wait for child process to finish
} else {
    // Child process
    echo "Child Process\n";
    sleep(2); // Simulate a task
    echo "Child Process Finished\n";
}
?>

Penjelasan:

• pcntl_fork() mencipta proses baharu.
• Proses ibu bapa dan proses anak berjalan serentak.
• Proses ibu bapa menunggu proses anak selesai menggunakan pcntl_wait().

2.2. Pemprosesan Asynchronous dengan ReactPHP

ReactPHP ialah perpustakaan untuk pengaturcaraan dipacu peristiwa dalam PHP, membenarkan operasi tak segerak.

Pemasangan:

composer require react/event-loop

Contoh:

<?php
require 'vendor/autoload.php';

use React\EventLoop\Factory;
use React\Promise\PromiseInterface;

$loop = Factory::create();

// Function to simulate an asynchronous task
function asyncTask($name) {
    return new PromiseInterface(function ($resolve, $reject) use ($name) {
        echo "Starting $name...\n";
        sleep(2); // Simulate a delay
        echo "$name completed.\n";
        $resolve();
    });
}

$promise1 = asyncTask('Task 1');
$promise2 = asyncTask('Task 2');

// Wait for all promises to complete
$loop->run();
?>

Penjelasan:

• ReactPHP mendayakan pelaksanaan tugas tak segerak.
• Tugas dijalankan serentak, dengan gelung acara menguruskan pelaksanaannya.

3. Keselarian dalam PHP

Paralelisme melibatkan pelaksanaan pelbagai tugas serentak. Dalam PHP, ini boleh dicapai menggunakan alatan dan perpustakaan yang direka untuk pemprosesan selari.

3.1. Menggunakan Sambungan selari

Pelanjutan selari membolehkan pemprosesan selari dalam PHP dengan mendayakan pelbagai benang.

Pemasangan:

• Pasang sambungan selari menggunakan PECL atau susun daripada sumber.

Contoh:

<?php
// Check if parallel is available
if (!extension_loaded('parallel')) {
    die('The parallel extension is not available.');
}

use parallel\{Runtime, Future};

// Function to run in parallel
function task($name) {
    echo "Task $name started\n";
    sleep(2); // Simulate a task
    echo "Task $name completed\n";
}

// Create runtime environments
$runtime1 = new Runtime();
$runtime2 = new Runtime();

// Start tasks in parallel
$future1 = $runtime1->run(function() {
    task('1');
});
$future2 = $runtime2->run(function() {
    task('2');
});

// Wait for tasks to complete
$future1->value();
$future2->value();
?>

Penjelasan:

• selari membolehkan mencipta berbilang persekitaran masa jalan.
• Tugas dijalankan selari merentasi urutan yang berbeza.

3.2. Menggunakan pthreads Extension

Pelanjutan pthreads membenarkan skrip PHP membuat, membaca dan menulis pada urutan.

Pemasangan:

• Pasang sambungan pthreads menggunakan PECL.

Contoh:

<?php
// Check if pthreads is available
if (!extension_loaded('pthreads')) {
    die('The pthreads extension is not available.');
}

class Worker extends Thread {
    private $name;

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

    public function run() {
        echo "Thread {$this->name} started\n";
        sleep(2); // Simulate a task
        echo "Thread {$this->name} completed\n";
    }
}

$worker1 = new Worker('1');
$worker2 = new Worker('2');

// Start threads
$worker1->start();
$worker2->start();

// Join threads to main script
$worker1->join();
$worker2->join();
?>

Penjelasan:

• pthreads menyediakan sokongan threading.
• Benang menjalankan tugas secara selari, menggunakan berbilang teras CPU.

4. Kesimpulan

Memahami dan melaksanakan konkurensi dan keselarian dalam PHP boleh meningkatkan prestasi dan responsif aplikasi anda dengan ketara. Dengan menggunakan teknik seperti proses forking, pemprosesan tak segerak dan multi-threading, anda boleh mengendalikan berbilang tugas dengan lebih cekap. Pilih pendekatan yang paling sesuai dengan keperluan dan persekitaran anda untuk mencapai prestasi optimum.

Jangan ragu untuk menyesuaikan contoh ini berdasarkan kes penggunaan khusus anda dan persekitaran PHP.

Atas ialah kandungan terperinci Meneroka Concurrency dan Paralelisme dalam PHP: Tutorial dan Petua Hands-On. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!