shmop_write — Funktion · PHP-Referenz

Signatur

shmop_write(Shmop $shmop, string $data, int $offset): int|false

Beschreibung

shmop_write() schreibt einen String in einen zuvor mit shmop_open() geöffneten oder erstellten Shared-Memory-Block. Der Parameter $offset gibt an, ab welcher Byte-Position im Block geschrieben werden soll. Die Funktion eignet sich für die Inter-Prozess-Kommunikation (IPC) zwischen mehreren PHP-Prozessen oder zwischen PHP und anderen Prozessen auf dem gleichen System.

Der geschriebene String darf zusammen mit dem Offset die Gesamtgröße des Shared-Memory-Blocks nicht überschreiten, andernfalls schlägt die Funktion fehl. Es empfiehlt sich daher, die verfügbare Blockgröße vorab mit shmop_size() zu prüfen.

Shared Memory ist deutlich schneller als dateibasierte IPC-Mechanismen, da keine Disk-I/O stattfindet. Es ist jedoch keine Synchronisation eingebaut — bei gleichzeitigem Zugriff mehrerer Prozesse sollten Sperrmechanismen (z. B. Semaphoren via sem_acquire()) eingesetzt werden, um Race Conditions zu vermeiden.

Ab PHP 8.0 wird ein Shmop-Objekt statt einer Ressource verwendet.

Parameter

Name	Typ	Beschreibung
$shmop Pflicht	Shmop	Das `Shmop`-Objekt (vor PHP 8.0: eine Ressource), das mit `shmop_open()` zurückgegeben wurde.
$data Pflicht	string	Der zu schreibende String. Die Länge bestimmt, wie viele Bytes in den Shared-Memory-Block geschrieben werden.
$offset Pflicht	int	Byte-Position im Shared-Memory-Block, ab der geschrieben werden soll. Muss `>= 0` sein und darf zusammen mit der Datenlänge die Blockgröße nicht überschreiten.

Rückgabewert

Typ

int|false

Beschreibung

Gibt die Anzahl der tatsächlich geschriebenen Bytes zurück. Im Fehlerfall (z. B. Offset + Datenlänge übersteigt die Blockgröße) wird false zurückgegeben.

Beispiele

Einfaches Schreiben und Lesen im Shared Memory

<?php
// Shared-Memory-Block erstellen: 1024 Bytes, Schlüssel 0x1234
$shm = shmop_open(0x1234, 'c', 0644, 1024);

if ($shm === false) {
    die('Shared Memory konnte nicht erstellt werden.');
}

$data = 'Hallo, Shared Memory!';
$written = shmop_write($shm, $data, 0);

if ($written === false) {
    echo 'Fehler beim Schreiben.' . PHP_EOL;
} else {
    echo "Geschrieben: $written Bytes" . PHP_EOL;
}

// Daten wieder auslesen
$read = shmop_read($shm, 0, $written);
echo 'Gelesen: ' . $read . PHP_EOL;

shmop_close($shm);
// Block löschen
$shm = shmop_open(0x1234, 'w', 0, 0);
shmop_delete($shm);
shmop_close($shm);

Geschrieben: 21 Bytes Gelesen: Hallo, Shared Memory!

Schreiben an einem bestimmten Offset

<?php
$key = ftok(__FILE__, 'x');
$shm = shmop_open($key, 'c', 0644, 256);

if ($shm === false) {
    die('Shared Memory nicht verfügbar.');
}

// Erstes Segment: Statusbyte (1 Byte)
shmop_write($shm, "1", 0);

// Zweites Segment: Nutzlast ab Byte 1
$payload = 'Daten-Paket-XY';
shmop_write($shm, $payload, 1);

// Alles lesen
$status  = shmop_read($shm, 0, 1);
$content = shmop_read($shm, 1, strlen($payload));

echo 'Status: '  . $status  . PHP_EOL;
echo 'Inhalt: '  . $content . PHP_EOL;

shmop_delete($shm);
shmop_close($shm);

Status: 1 Inhalt: Daten-Paket-XY

// Wichtig · Fallstricke

Race Conditions: Shared Memory bietet keinerlei eingebaute Synchronisation. Wenn mehrere Prozesse gleichzeitig schreiben oder lesen, können inkonsistente Daten entstehen. Verwende in solchen Szenarien PHP-Semaphoren (sem_acquire() / sem_release()), um den Zugriff zu serialisieren.

Blockgröße nicht überschreiten: Ist $offset + strlen($data) > shmop_size($shm), schlägt die Funktion fehl. Prüfe die Größe vorab mit shmop_size().

Binäre Daten: Da Shared Memory rohe Bytes speichert, müssen komplexe Strukturen (Arrays, Objekte) vor dem Schreiben serialisiert (serialize() / json_encode()) und nach dem Lesen deserialisiert werden. Achte dabei auf die resultierende Stringlänge.

PHP 8.0+: Ab PHP 8.0 liefert shmop_open() ein Shmop-Objekt statt einer Ressource; shmop_write() erwartet entsprechend dieses Objekt.

Siehe auch

shmop_open shmop_read shmop_size shmop_delete shmop_close sem_acquire