Mécanisme de synchronisation de la structure des données sous programmation simultanée PHP

Dans la programmation simultanée PHP, le mécanisme de synchronisation de la structure de données suivant est crucial : section critique : utilisez le mot-clé synchronisé pour protéger la zone de code de la section critique, permettant à un seul thread de s'exécuter à la fois ; verrouillage mutex : assuré par le lock() et Méthodes unlock() Un seul thread à la fois accède aux ressources partagées ; verrouillage en lecture-écriture : permet à plusieurs threads de lire en même temps, mais n'autorise qu'un seul thread à la fois à écrire des données partagées : file d'attente FIFO, utilisée pour délivrer des messages et des tâches ; pile : structure de données LIFO, utilisée pour gérer le contexte d'appel. Dans le cas réel, le robot d'exploration simultané utilise une file d'attente pour stocker les URL analysées et utilise un verrou mutex pour protéger les droits d'accès de la file d'attente afin d'assurer la sécurité des threads.

Mécanisme de synchronisation de la structure des données sous programmation simultanée PHP

Dans la programmation simultanée PHP, le mécanisme de synchronisation est crucial pour garantir l'exactitude et la cohérence lorsque plusieurs threads ou processus accèdent aux données partagées en même temps. Cet article explorera les mécanismes courants de synchronisation des structures de données en PHP et fournira des exemples pratiques pour illustrer.

Critical Section

Critical Section est un mécanisme de synchronisation utilisé pour protéger une région de code afin qu'elle ne puisse être exécutée que par un seul thread à la fois. En PHP, les sections critiques peuvent être déclarées à l'aide du mot-clé synchronized. 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

Un mutex est un objet de verrouillage utilisé pour garantir qu'un seul thread peut accéder à une ressource partagée à la fois. Il existe diverses implémentations de mutex en PHP, telles que les classes Mutex et 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();
}

Verrou en lecture-écriture

🎜🎜Un verrou en lecture-écriture est un objet de verrouillage qui permet à plusieurs threads de lire des données partagées en même temps, mais un seul thread peut écrire des données partagées à la fois. La classe RWLock en PHP peut implémenter des verrous en lecture-écriture. 🎜rrreee🎜🎜Queue🎜🎜🎜Queue est une structure de données FIFO (premier entré, premier sorti) qui peut être utilisée pour transmettre des messages et des tâches dans un environnement simultané. La classe SplQueue en PHP fournit une implémentation de file d'attente. 🎜rrreee🎜🎜Stack🎜🎜🎜La pile est une structure de données LIFO (dernier entré, premier sorti) qui peut être utilisée pour gérer le contexte d'appel dans un environnement simultané. La classe SplStack en PHP fournit une implémentation de pile. 🎜rrreee🎜🎜Cas pratique : Crawler simultané🎜🎜🎜Dans un robot parallèle, la liste d'URL explorées est une structure de données partagée et nécessite un mécanisme de synchronisation pour garantir la sécurité des threads. Une pratique courante consiste à utiliser une file d'attente pour stocker les URL analysées et à utiliser un mutex pour protéger l'accès à la file d'attente. 🎜rrreee🎜Dans ce cas, la file d'attente et le verrouillage mutex réalisent conjointement le contrôle de synchronisation de l'exploration simultanée multithread, garantissant l'accès et la modification corrects de la liste d'URL. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!