What are the techniques for handling concurrency in PHP?

The examples in this article describe several implementation methods to solve concurrency problems in PHP development. Sharing it with everyone for your reference, the details are as follows:

## For concurrent scenarios such as product rush buying, oversold may occur phenomenon, then 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 to achieve concurrency control.

Option 1: Use file lock exclusive lock (Recommended learning: PHP video tutorial)

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

When acquiring the lock, first query the inventory. If the inventory is greater than 0, place an order. Operate, 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 At this time, other processes cannot operate on this row of data

Query and lock the row first:

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 a queue

The order requests are stored in a queue in turn, and a separate process is used in the background to process the order requests in the queue

Option 4: Using Redis

The operations of redis are all It is atomic. You can store the inventory of goods in redis. Before placing an order, perform a decr operation on the inventory. 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 At this time, the amount of concurrency is very large, and there will be many processes going to the database to fetch 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

$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

The above is the detailed content of What are the techniques for handling concurrency in PHP?. For more information, please follow other related articles on the PHP Chinese website!