Analysis of several implementation methods to solve concurrency problems in PHP development

The examples in this article describe several implementation methods to solve concurrency problems in PHP development, and share them with you for your reference.

In concurrent scenarios such as product rush-buying, overselling may occur. At this time, it is necessary to solve the problems caused by concurrency.

There is no native provision in the PHP language Concurrency solutions require other ways to achieve concurrency control.

Option 1: Use file lock exclusive lock

Theflock function is used to obtain the file lock. This lock can only Acquired by one thread, other threads that have not acquired the lock will either block or fail to acquire it

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

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

Innodb storage engine supports row-level locks. When the row data is locked, other processes cannot operate on the row 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 queue

Save the user's order requests into a queue in sequence, and use a separate process in the background to process the order requests in the queue

Option 4: Use Redis

The operations of redis are all 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. High

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 When it fails, go to the database to fetch data and reset the cache. If the concurrency is large at this time, many processes will go to the database to fetch data at the same time, causing many requests to

penetrate to the database and cause the database to crash. File locks can be used to solve the problem here

$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 reading:

MySQL redis learning and application

Implementation of transaction mechanism and optimistic locking in redis Method

MySQL database optimization (3)—MySQL pessimistic locking and optimistic locking (concurrency control)

The above is the detailed content of Analysis of several implementation methods to solve concurrency problems in PHP development. For more information, please follow other related articles on the PHP Chinese website!