Several implementations of PHP to solve concurrency problems

This article introduces several implementations of PHP to solve concurrency problems. It has certain reference value. Now I share it with you. Friends in need can refer to it.

For concurrency scenarios such as product rush buying Under this situation, oversold phenomena may occur. At this time, you need to solve the problems caused by concurrency.

There is no native concurrency solution in the PHP language, so you need to use other methods. Implement concurrency control.

Option 1: Use file lock exclusive lock

Theflock function is used to obtain the file lock. This lock can only be obtained by one thread at the same time. Other threads that have not obtained the lock will either be blocked. , or the acquisition fails

When acquiring the lock, first query the inventory. If the inventory is greater than 0, place an order, reduce the inventory, and then release the lock

Option 2: Use the pessimistic lock provided by the Mysql database

Innodb storage engine supports row-level locks. When a row of data is locked, other processes cannot operate on the row of data

First query and lock the row: select stock_num from table where id=1 for update

if(stock_num > 0){
//下订单
update table set stock_num=stock-1 where id=1
}

Option 3: Use queue

to store the user’s order requests into a queue in sequence, and use a queue in the background A separate process processes the order request in the queue

Option 4: Using Redis

Redis operations are all atomic, and the inventory of goods can be Store it in redis and perform a decr operation on the inventory before placing an order. If the returned value is greater than or equal to 0, you can place an order. Otherwise, you cannot place an order. This method is more efficient.

if(redis->get('stock_num') > 0){
 stock_num = redis->decr('stock_num')
 if(stock_num >= 0){
 //下订单
 }else{
 //库存不足
 }
}else{
//库存不足
}

Other concurrency issues:

In real applications, in many cases data will be stored in the cache. When the cache fails, go to the database to retrieve the data and reset the cache. If the amount of concurrency is large at this time, There will be many processes going to the database to retrieve data at the same time, resulting in many requests

penetrating into the database and causing the database to crash. File locks can be used to solve this problem

##[php] view plain copy

$data = $cache->get('key');  
if(!$data){  
    $fp = fopen('lockfile');  
    if(flock($fp, LOCK_EX)){  
        $data = $cache->get('key');//拿到锁后再次检查缓存，这时可能已经有了  
        if(!$data){  
            $data = mysql->query();  
            $cache->set('key', $data);  
        }  
        flock($fp, LOCK_UN);  
    }  
    fclose($fp);  
}

To put it bluntly, locking is necessary to solve concurrency problems. The essence of various solutions is locking

Related recommendations:

php solves the problem of loss when posting large amounts of data

PHP solves session file blocking

PHP solves JSON Chinese display problem

The above is the detailed content of Several implementations of PHP to solve concurrency problems. For more information, please follow other related articles on the PHP Chinese website!