Datenstruktur-Synchronisationsmechanismus unter PHP-Parallelprogrammierung

Bei der gleichzeitigen PHP-Programmierung ist der folgende Mechanismus zur Synchronisierung der Datenstruktur von entscheidender Bedeutung: Kritischer Abschnitt: Verwenden Sie das synchronisierte Schlüsselwort, um den Codebereich des kritischen Abschnitts zu schützen, sodass jeweils nur ein Thread ausgeführt werden kann: Wird durch lock() und sichergestellt unlock()-Methoden: Es kann immer nur ein Thread auf gemeinsam genutzte Ressourcen zugreifen. Lese-/Schreibsperre: Ermöglicht das gleichzeitige Lesen mehrerer Threads, aber nur das gleichzeitige Schreiben gemeinsam genutzter Daten. Warteschlange: FIFO-Datenstruktur Übermittlung von Nachrichten und Aufgabenstapel: LIFO-Datenstruktur, wird zum Verwalten des Aufrufkontexts verwendet. Im tatsächlichen Fall verwendet der gleichzeitige Crawler eine Warteschlange zum Speichern der gecrawlten URLs und verwendet eine Mutex-Sperre, um die Zugriffsrechte der Warteschlange zu schützen und Thread-Sicherheit zu erreichen.

Datenstruktur-Synchronisierungsmechanismus unter PHP-Parallelprogrammierung

Bei der PHP-Parallelprogrammierung ist der Synchronisationsmechanismus entscheidend, um die Korrektheit und Konsistenz sicherzustellen, wenn mehrere Threads oder Prozesse gleichzeitig auf gemeinsam genutzte Daten zugreifen. In diesem Artikel werden gängige Mechanismen zum Synchronisieren von Datenstrukturen in PHP untersucht und praktische Beispiele zur Veranschaulichung bereitgestellt.

Kritischer Abschnitt

Kritischer Abschnitt ist ein Synchronisierungsmechanismus, der zum Schutz eines Codebereichs verwendet wird, sodass er jeweils nur von einem Thread ausgeführt werden kann. In PHP können kritische Abschnitte mit dem Schlüsselwort synchronized deklariert werden. synchronized 关键字来声明临界区。

class Foo {
    private $data = [];

    public function bar() {
        // 临界区开始
        synchronized($this->data) {
            // 临界区代码，只允许一个线程同时执行
        }
        // 临界区结束
    }
}

互斥锁

互斥锁是一种锁对象，用于确保一次只有一个线程可以访问共享资源。PHP 中有多种互斥锁实现，例如 Mutex 和 Semaphore 类。

$mutex = new Mutex();

$mutex->lock();
try {
    // 临界区代码...
} finally {
    $mutex->unlock();
}

读写锁

读写锁是一种允许多个线程同时读共享数据，但一次只能有一个线程写共享数据的锁对象。PHP 中的 RWLock 类可以实现读写锁。

$rwLock = new RWLock();

$rwLock->lockReadOnly();
try {
    // 多个线程可以同时读取共享数据
} finally {
    $rwLock->unlockReadOnly();
}

$rwLock->lockWrite();
try {
    // 只有一个线程可以写入共享数据
} finally {
    $rwLock->unlockWrite();
}

队列

队列是一种 FIFO（先进先出）的数据结构，可用于在并发环境中传递消息和任务。PHP 中的 SplQueue 类提供了队列实现。

$queue = new SplQueue();

$queue->enqueue('任务 1');
$queue->enqueue('任务 2');

while (!$queue->isEmpty()) {
    $task = $queue->dequeue();
    // 处理任务
}

栈

栈是一种 LIFO（后进先出）的数据结构，可用于在并发环境中管理调用上下文。PHP 中的 SplStack

$stack = new SplStack();

$stack->push('调用 1');
$stack->push('调用 2');

while (!$stack->isEmpty()) {
    $call = $stack->pop();
    // 处理调用
}

Mutex

Ein Mutex ist ein Sperrobjekt, das verwendet wird, um sicherzustellen, dass jeweils nur ein Thread auf eine gemeinsam genutzte Ressource zugreifen kann. Es gibt verschiedene Mutex-Implementierungen in PHP, beispielsweise die Klassen Mutex und Semaphore.

class Crawler {
    private $queue;
    private $mutex;
    
    public function __construct() {
        $this->queue = new SplQueue();
        $this->mutex = new Mutex();
    }
    
    public function addUrl($url) {
        $this->mutex->lock();
        try {
            $this->queue->enqueue($url);
        } finally {
            $this->mutex->unlock();
        }
    }
    
    public function getNextUrl() {
        $this->mutex->lock();
        try {
            return $this->queue->dequeue();
        } finally {
            $this->mutex->unlock();
        }
    }
}

$crawler = new Crawler();

// 多个线程并发抓取 URL
$threads = [];
for ($i = 0; $i < 10; $i++) {
    $threads[] = new Thread(function() use ($crawler) {
        while (($url = $crawler->getNextUrl()) !== null) {
            // 抓取并处理 URL
        }
    });
}

foreach ($threads as $thread) {
    $thread->start();
}

foreach ($threads as $thread) {
    $thread->join();
}

Lese-/Schreibsperre

🎜🎜Eine Lese-/Schreibsperre ist ein Sperrobjekt, das es mehreren Threads ermöglicht, gemeinsam genutzte Daten gleichzeitig zu lesen, aber nur ein Thread kann jeweils gemeinsam genutzte Daten schreiben. Die Klasse RWLock in PHP kann Lese-/Schreibsperren implementieren. 🎜rrreee🎜🎜Queue🎜🎜🎜Queue ist eine FIFO-Datenstruktur (First In, First Out), die zur Zustellung von Nachrichten und Aufgaben in einer gleichzeitigen Umgebung verwendet werden kann. Die SplQueue-Klasse in PHP stellt eine Warteschlangenimplementierung bereit. 🎜rrreee🎜🎜Stack🎜🎜🎜Der Stack ist eine LIFO-Datenstruktur (Last In First Out), die zum Verwalten des Aufrufkontexts in einer gleichzeitigen Umgebung verwendet werden kann. Die SplStack-Klasse in PHP stellt eine Stack-Implementierung bereit. 🎜rrreee🎜🎜Praktischer Fall: Gleichzeitiger Crawler🎜🎜🎜In einem parallelen Crawler ist die gecrawlte URL-Liste eine gemeinsam genutzte Datenstruktur und erfordert einen Synchronisierungsmechanismus, um die Thread-Sicherheit sicherzustellen. Eine gängige Praxis besteht darin, eine Warteschlange zum Speichern der gecrawlten URLs zu verwenden und einen Mutex zu verwenden, um den Zugriff auf die Warteschlange zu schützen. 🎜rrreee🎜In diesem Fall realisieren die Warteschlange und die Mutex-Sperre gemeinsam die Synchronisationssteuerung des gleichzeitigen Multithread-Crawlings und stellen so den korrekten Zugriff und die korrekte Änderung der URL-Liste sicher. 🎜

Das obige ist der detaillierte Inhalt vonDatenstruktur-Synchronisationsmechanismus unter PHP-Parallelprogrammierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!