Start · Sprachen · PHP · Referenz · inotify_queue_len

inotify_queue_len

Funktion

Gibt die Anzahl der ausstehenden Ereignisse in der inotify-Warteschlange zurück.

seit PHP 0.1.0 Kategorie: io

Signatur

inotify_queue_len(resource $inotify_instance): int

Beschreibung

inotify_queue_len() fragt ab, wie viele Ereignisse in der internen Warteschlange eines inotify-Handles auf die Verarbeitung warten. Der Rückgabewert ist eine nicht-negative ganze Zahl: 0 bedeutet, dass keine Ereignisse anstehen; ein Wert größer als null zeigt an, dass mit inotify_read() Ereignisse abgeholt werden können.

Die Funktion eignet sich besonders gut in nicht-blockierenden Polling-Schleifen: Anstatt direkt inotify_read() aufzurufen (was blockieren könnte), prüft man zunächst mit inotify_queue_len(), ob überhaupt Ereignisse vorliegen, und liest sie nur bei Bedarf aus.

Intern entspricht der Rückgabewert dem FIONREAD-ioctl-Wert auf dem zugrundeliegenden inotify-Dateideskriptor, geteilt durch die Größe einer inotify_event-Struktur. Beachte, dass Dateinamen variabler Länge die Zählung geringfügig beeinflussen können — der Wert sollte daher als Richtwert (mindestens so viele Ereignisse) betrachtet werden.

Die Funktion steht nur zur Verfügung, wenn die PECL-Erweiterung inotify installiert und geladen ist, da inotify ein Linux-spezifisches Kernel-Feature ist.

Parameter

Name Typ Default Beschreibung
$inotify_instance Pflicht resource Ein gültiges inotify-Handle, das zuvor mit inotify_init() erzeugt wurde.

Rückgabewert

Typ
int
Beschreibung
Gibt die Anzahl der ausstehenden Ereignisse in der Warteschlange zurück. Ein Wert von 0 bedeutet, dass keine Ereignisse bereitstehen. Ein Wert größer als 0 zeigt an, dass Ereignisse mit inotify_read() abgeholt werden können.

Beispiele

Nicht-blockierendes Polling auf Dateiänderungen

<?php
// inotify-Handle erstellen
$inotify = inotify_init();

// Verzeichnis überwachen
$watchDescriptor = inotify_add_watch($inotify, '/tmp', IN_CREATE | IN_MODIFY | IN_DELETE);

// Nicht-blockierenden Modus aktivieren
stream_set_blocking($inotify, false);

echo "Überwache /tmp auf Ereignisse ..." . PHP_EOL;

for ($i = 0; $i < 10; $i++) {
    $pending = inotify_queue_len($inotify);

    if ($pending > 0) {
        echo "Ausstehende Ereignisse: {$pending}" . PHP_EOL;
        $events = inotify_read($inotify);
        foreach ($events as $event) {
            echo "Ereignis-Maske: " . $event['mask'] . ", Name: " . $event['name'] . PHP_EOL;
        }
    } else {
        echo "Keine Ereignisse in Iteration {$i}." . PHP_EOL;
    }

    usleep(200000); // 200 ms warten
}

inotify_rm_watch($inotify, $watchDescriptor);
fclose($inotify);
Überwache /tmp auf Ereignisse ... Keine Ereignisse in Iteration 0. Ausstehende Ereignisse: 1 Ereignis-Maske: 256, Name: testdatei.txt ...

Kombination mit stream_select für effizientes Warten

<?php
$inotify = inotify_init();
inotify_add_watch($inotify, '/var/log', IN_MODIFY);

stream_set_blocking($inotify, false);

$read   = [$inotify];
$write  = [];
$except = [];

// Bis zu 2 Sekunden auf Ereignisse warten
$changed = stream_select($read, $write, $except, 2);

if ($changed === false) {
    echo "Fehler bei stream_select." . PHP_EOL;
} elseif ($changed === 0) {
    echo "Timeout: Keine Ereignisse innerhalb von 2 Sekunden." . PHP_EOL;
} else {
    $len = inotify_queue_len($inotify);
    echo "Mindestens {$len} Ereignis(se) vorhanden. Lese jetzt ..." . PHP_EOL;
    $events = inotify_read($inotify);
    foreach ($events as $event) {
        echo "Datei geändert: " . $event['name'] . PHP_EOL;
    }
}

fclose($inotify);
Mindestens 1 Ereignis(se) vorhanden. Lese jetzt ... Datei geändert: syslog

// Wichtig · Fallstricke

Linux-exklusiv: inotify ist ein Linux-Kernel-Feature und steht unter Windows oder macOS nicht zur Verfügung. Skripte, die diese Funktion verwenden, sind daher nicht portabel.

PECL-Erweiterung erforderlich: Die Funktion ist Teil der PECL-Erweiterung inotify und nicht im PHP-Kern enthalten. Sie muss separat installiert werden (pecl install inotify).

Richtwert, kein exakter Zähler: Der zurückgegebene Wert basiert auf der Bytes-in-Puffer-Schätzung des Kernels. Bei Ereignissen mit langen Dateinamen kann die tatsächliche Anzahl der lesbaren Ereignisse geringfügig abweichen. Der Wert ist aber immer eine sichere Untergrenze.