PHP IPC with Daemon Service using Message Queues, Shared Memory and Semaphores

// Convert a path name and a project identifier to a System V IPC key
$key = ftok(__FILE__, 'A'); // 555 for example

// Creating a message queue with a key, we need to use an integer value.
$queue = msg_get_queue($key);

// Send a message. Note that all required fields are already filled,
// but sometimes you want to serialize an object and put on a message or a lock.
// Note that we specify a different type. Type - is a certain group in the queue.
msg_send($queue, 1, 'message, type 1');
msg_send($queue, 2, 'message, type 2');
msg_send($queue, 3, 'message, type 3');
msg_send($queue, 1, 'message, type 1');

echo "send 4 messages\n";

$key = ftok('queue-send.php', 'A'); // 555 for example
$queue = msg_get_queue($key);

// Loop through all types of messages.
for ($i = 1; $i <= 3; $i++) {
    echo "type: {$i}\n";

// Loop through all, read messages are removed from the queue.
// Here we find a constant MSG_IPC_NOWAIT, without it all will hang forever.
    while ( msg_receive($queue, $i, $msgtype, 4096, $message, false, MSG_IPC_NOWAIT) ) {
        echo "type: {$i}, msgtype: {$msgtype}, message: {$message}\n";
    }
}

u% php queue-send.php
send 4 messages
u% php queue-receive.php
type: 1
type: 1, msgtype: 1, message: s:15:"message, type 1";
type: 1, msgtype: 1, message: s:15:"message, type 1";
type: 2
type: 2, msgtype: 2, message: s:15:"message, type 2";
type: 3
type: 3, msgtype: 3, message: s:15:"message, type 3";

while (msg_receive($queue, $i, $msgtype, 4096, $message, false, MSG_IPC_NOWAIT)) {
// ... 

$key = ftok('queue-send.php', 'A'); // 555 for example
$queue = msg_get_queue($key);

// Loop through all types of messages.
// Loop through all, read messages are removed from the queue.
while ( msg_receive($queue, 0, $msgtype, 4096, $message) ) {
    echo "msgtype: {$msgtype}, message: {$message}\n";
} 

// Fork process
$pid = pcntl_fork();
$key = ftok('queue-send.php', 'A');
$queue = msg_get_queue($key);

if ($pid == -1) {
    exit;
} elseif ($pid) {
    exit;
} else {
    while ( msg_receive($queue, 0, $msgtype, 4096, $message) ) {
        echo "msgtype: {$msgtype}, message: {$message}\n";
    }
}

// Disengaged from the terminal
posix_setsid();

Shared Memory

// This is the correct and recommended way to obtain a unique identifier.
// Based on this approach, the system uses the inode table of the file system
// and for greater uniqueness converts this number based on the second parameter.
// The second parameter always goes one letter
$id = ftok(__FILE__, 'A');

// Create or open the memory block
// Here you can specify additional parameters, in particular the size of the block
// or access rights for other users to access this memory block.

// We can simply specify the id instead of any integer value
$shmId = shm_attach($id);

// As we have shared variables (any integer value)
$var = 1;

// Check if we have the requested variables.
if (shm_has_var($shmId, $var)) {
    // If so, read the data
    $data = (array) shm_get_var($shmId, $var);
} else {
    // If the data was not there.
    $data = array();
}

// Save the in the resulting array value of this file.
$data[time()] = file_get_contents(__FILE__);

// And writes the array in memory, specify where to save the variable.
shm_put_var($shmId, $var, $data);

// Easy? 

// Read data from memory.
$id = ftok(__DIR__ . '/shared-memory-write-base.php', 'A');
$shmId = shm_attach($id);
$var = 1; 

// Check if we have the requested variables.
if (shm_has_var($shmId, $var)) {
    $data = (array) shm_get_var($shmId, $var);
} else {
    $data = array();
}

// Iterate received and save them to files.
foreach ($data as $key => $value) {
    // A simple example, create a file from the data that we have saved.
    $path = "/tmp/$key.php";
    file_put_contents($path, $value);

    echo $path . PHP_EOL;
} 

Semaphores

// Let's try to save a binary file, the size of a couple of megabytes.
// This script does the following:
// If there is input, it reads it, otherwise it writes data into memory
// In this case, when writing to the memory we put a sign lock - semaphore

// Everything is as usual, read the previous comments 
$id = ftok(__FILE__, 'A');

// Obtain a resource semaphore - lock feature. There is nothing wrong if we
// use the same id that is used to obtain a resource shared memory 
$semId = sem_get($id);

// Put a lock. There's a caveat. If another process will encounter this lock,
// it will wait until the lock is removed 
sem_acquire($semId);

// Specify your like picture 
$data = file_get_contents(__DIR__.'/06050396.JPG', FILE_BINARY);

// These can be large, so precaution is necessary to allocate such a way that would be enough 
$shmId = shm_attach($id, strlen($data)+4096);
$var = 1;
 
if (shm_has_var($shmId, $var)) {
    // Obtain data from the memory 
         $data = shm_get_var($shmId, $var);

    // Save our file somewhere
    $filename = '/tmp/' . time();
    file_put_contents($filename, $data, FILE_BINARY);

    // Remove the memory block that started it all over again.
    shm_remove($shmId);
} else {
    shm_put_var($shmId, $var, $data); 
}

// Releases the lock. 
sem_release($semId); 

Conclusion