Bermula dengan PHP: Semaphore dan Memori Dikongsi

PHP, sebagai bahasa skrip, digunakan secara meluas dalam aplikasi rangkaian. Secara umumnya, PHP bukanlah bahasa yang berkaitan dengan operasi asas sistem, tetapi dalam beberapa senario khas, seperti pengaturcaraan serentak, pengaturcaraan berbilang proses, komunikasi antara proses, dll., masih perlu mempunyai pemahaman tertentu daripada sistem asas. Artikel ini akan memperkenalkan dua pengetahuan peringkat rendah yang berkaitan dengan komunikasi antara proses: semaphore dan memori dikongsi, dan menyediakan contoh penggunaan berkaitan semaphore dan memori dikongsi dalam PHP.

1. Semaphore

Dalam pengaturcaraan berbilang proses, untuk memastikan eksklusiviti bersama antara pelbagai proses, beberapa cara teknikal perlu digunakan untuk penyegerakan, dan semaphore adalah salah satu daripadanya. Semaphore ialah nilai integer yang mewakili jumlah sumber yang ada. Sebelum proses menggunakan sumber, ia perlu memohon untuk semaphore jika semaphore lebih besar daripada 0, ia bermakna bahawa sumber tidak diduduki dan mengurangkan semaphore sebanyak 1; ia bermakna bahawa sumber telah diduduki, dan proses perlu menunggu Apabila proses lain mengeluarkan sumber, proses itu akan digantung sehingga sumber dikeluarkan dan semaphore lebih besar daripada 0.

Dalam PHP, anda boleh menggunakan fungsi yang disediakan oleh modul Sistem V IPC untuk mengendalikan semaphore. Kod sampel adalah seperti berikut:

<?php
$sem_key = ftok(__FILE__, 't'); // 生成一个唯一的键值
$sem_id = sem_get($sem_key); // 根据键值获取一个信号量
if (sem_acquire($sem_id)) { // 获取信号量
    // 执行需要互斥的代码
    sem_release($sem_id); // 释放信号量
}
?>

Dalam contoh di atas, kami menggunakan fungsi ftok() untuk menjana nilai kunci unik dan memperoleh semaphore melalui fungsi sem_get(). Kemudian gunakan fungsi sem_acquire() untuk memperoleh semaphore Jika pemerolehan berjaya, ini bermakna tiada proses lain sedang menggunakan sumber dan anda boleh melaksanakan kod yang memerlukan pengecualian bersama Selepas pelaksanaan, gunakan fungsi sem_release(). lepaskan semafor.

Satu perkara yang perlu diberi perhatian ialah memandangkan pelaksanaan skrip PHP adalah satu-benang, anda perlu mempertimbangkan situasi proses kanak-kanak apabila menggunakan semaphore. Jika berbilang proses kanak-kanak menggunakan sumber yang sama pada masa yang sama, semafor perlu dimulakan untuk memastikan berbilang proses anak berkongsi semafor yang sama. Pada masa ini, anda boleh mendapatkan semaphore dan menetapkan nilai awal dalam proses induk, dan kemudian menghentikan proses anak Proses anak mula-mula menggunakan fungsi sem_attach() untuk mendapatkan semaphore sebelum menggunakan sumber, dan kemudian laksanakan. kod yang memerlukan pengecualian bersama selepas pemerolehan berjaya. Kod sampel adalah seperti berikut:

<?php
$sem_key = ftok(__FILE__, 't'); // 生成一个唯一的键值
$sem_id = sem_get($sem_key, 1, 0666, 1); // 获取一个信号量，设置初值为1
if (pcntl_fork() == 0) { // fork出一个子进程
    $child_sem_id = sem_attach($sem_key); // 子进程获取信号量
    if (sem_acquire($child_sem_id)) { // 子进程获取信号量成功
        // 执行需要互斥的代码
        sem_release($child_sem_id); // 释放信号量
    }
    sem_remove($child_sem_id); // 子进程释放信号量
    exit;
}

if (sem_acquire($sem_id)) { // 父进程获取信号量成功
    // 执行需要互斥的代码
    sem_release($sem_id); // 释放信号量
}
sem_remove($sem_id); // 父进程释放信号量
?>

Dalam contoh di atas, kami menggunakan fungsi pcntl_fork() untuk menghentikan proses anak. Proses anak memperoleh semaphore yang dibuat dalam proses induk melalui fungsi sem_attach() dan menggunakannya Selepas digunakan, fungsi sem_remove() perlu dipanggil untuk melepaskan semaphore.

2. Memori dikongsi

Memori dikongsi bermakna berbilang proses boleh berkongsi kawasan memori yang sama dan setiap proses boleh mengakses kawasan memori seperti memori tempatan. Memori yang dikongsi adalah serupa dengan semaphore kerana ia digunakan untuk mencapai komunikasi dan penyegerakan antara pelbagai proses, tetapi perbezaan daripada semaphore ialah memori yang dikongsi tidak digunakan untuk operasi pengecualian bersama, tetapi untuk perkongsian data.

Dalam PHP, anda boleh menggunakan fungsi yang disediakan oleh modul Sistem V IPC untuk mengendalikan memori kongsi. Kod sampel adalah seperti berikut:

<?php
$shm_key = ftok(__FILE__, 't'); // 获取唯一的键值
$shm_id = shmop_open($shm_key, 'c', 0666, 1024); // 打开共享内存并设置大小为1024字节
if ($shm_id) {
    $data = 'hello world';
    shmop_write($shm_id, $data, 0); // 向共享内存写入数据
    $read_data = shmop_read($shm_id, 0, 11); // 从共享内存读取数据
    echo $read_data;
    shmop_delete($shm_id); // 删除共享内存
}
?>

Dalam contoh di atas, kami menggunakan fungsi ftok() untuk mendapatkan nilai kunci unik, dan kemudian menggunakan fungsi shmop_open() untuk membuka memori kongsi dengan saiz 1024 bait, dan fungsi shmop_write() Tulis data ke memori yang dikongsi, fungsi shmop_read() membaca data daripada memori yang dikongsi, dan akhirnya menggunakan fungsi shmop_delete() untuk memadamkan memori yang dikongsi.

Perlu diambil perhatian bahawa apabila menggunakan memori dikongsi, anda perlu mempertimbangkan situasi di mana berbilang proses mengendalikan kawasan memori yang sama pada masa yang sama, dan ketidakkonsistenan data mungkin berlaku. Pada masa ini, adalah disyorkan untuk menggunakan semaphore untuk mengawal operasi membaca dan menulis pada memori yang dikongsi untuk memastikan bahawa hanya satu proses membaca dan menulis ke kawasan memori pada masa yang sama untuk mengelakkan ketidakkonsistenan data.

Ringkasan

Artikel ini memperkenalkan dua pengetahuan asas yang berkaitan dengan komunikasi antara proses dalam PHP: semaphore dan memori dikongsi serta menyediakan kod contoh yang berkaitan. Apabila melakukan pengaturcaraan berbilang proses atau pengaturcaraan serentak, memahami semaphore dan memori yang dikongsi boleh membantu kita mengelakkan konflik antara proses dan mencapai perkongsian data dengan lebih baik.

Atas ialah kandungan terperinci Bermula dengan PHP: Semaphore dan Memori Dikongsi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!