Data structure synchronization mechanism under PHP concurrent programming

In PHP concurrent programming, the following data structure synchronization mechanism is crucial: critical section: use the synchronized keyword to protect the critical section code area, allowing only one thread to execute at a time; mutex lock: through lock() and unlock() Method ensures that only one thread accesses shared resources at a time; read-write lock: allows multiple threads to read at the same time, but only allows one thread to write shared data at a time; queue: FIFO data structure, used to deliver messages and tasks; stack: LIFO data Structure used to manage calling context. In the actual case, the concurrent crawler uses a queue to store the crawled URLs, and uses a mutex to protect the access rights of the queue to achieve thread safety.

Data structure synchronization mechanism under PHP concurrent programming

In PHP concurrent programming, the synchronization mechanism is crucial and is used for Ensure correctness and consistency when multiple threads or processes access shared data simultaneously. This article will explore common mechanisms for synchronizing data structures in PHP and provide practical examples to illustrate.

Critical Section

The critical section is a synchronization mechanism used to protect a code area so that it can only be executed by one thread at a time. In PHP, critical sections can be declared using the synchronized keyword.

class Foo {
    private $data = [];

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

Mutex lock

A mutex lock is a lock object used to ensure that only one thread can access a shared resource at a time. There are various mutex implementations in PHP, such as the Mutex and Semaphore classes.

$mutex = new Mutex();

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

Read-write lock

Read-write lock is a lock object that allows multiple threads to read shared data at the same time, but only one thread can write shared data at a time . The RWLock class in PHP can implement read-write locks.

$rwLock = new RWLock();

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

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

Queue

Queue is a FIFO (first in, first out) data structure that can be used to deliver messages and tasks in a concurrent environment. The SplQueue class in PHP provides queue implementation.

$queue = new SplQueue();

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

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

Stack

The stack is a LIFO (last in first out) data structure that can be used to manage call contexts in a concurrent environment. The SplStack class in PHP provides stack implementation.

$stack = new SplStack();

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

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

Practical case: Concurrent crawler

In a parallel crawler, the crawled URL list is a shared data structure, which requires a synchronization mechanism to ensure thread safety. A common practice is to use a queue to store the crawled URLs and use a mutex to protect access to the queue.

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();
}

In this case, the queue and mutex lock jointly realize the synchronization control of multi-threaded concurrent crawling, ensuring the correct access and modification of the URL list.

The above is the detailed content of Data structure synchronization mechanism under PHP concurrent programming. For more information, please follow other related articles on the PHP Chinese website!