3 Solutions for PHP Concurrency Scenarios

In concurrent scenarios such as flash sales and rush sales, overselling may occur. There is no native concurrency solution in the PHP language, so other methods are needed to achieve it. Concurrency control.

The common solutions listed are:

Use a queue, set up an extra process to handle the queue, put all concurrent requests in the queue, and handle them serially by the extra process, so the concurrency problem does not exist. However, it requires additional process support and serious processing delays. This article will not discuss this method first.

Use the transaction characteristics of the database to perform atomic updates. This method needs to rely on the transaction characteristics of the database.

With the help of file exclusive lock, when processing an order request, use flock to lock a file. Only those who successfully obtain the lock can process the order.

1. Utilize Redis transaction features

Redis transactions are atomic operations, which can ensure that the data is not modified by other concurrent processes during order processing.

Sample code:

<?php
$http = new swoole_http_server("0.0.0.0", 9509);   // 监听 9509
$http->set(array(
    &#39;reactor_num&#39; => 2,  //reactor thread num
    &#39;worker_num&#39; => 4    //worker process num
));
$http->on(&#39;request&#39;, function (swoole_http_request $request, swoole_http_response $response) {
    $uniqid = uniqid(&#39;uid-&#39;, TRUE);    // 模拟唯一用户ID
    $redis = new Redis();
    $redis->connect(&#39;127.0.0.1&#39;, 6379);    // 连接 redis
    $redis->watch(&#39;rest_count&#39;);  // 监测 rest_count 是否被其它的进程更改
    $rest_count = intval($redis->get("rest_count"));  // 模拟唯一订单ID
    if ($rest_count > 0){
        $value = "{$rest_count}-{$uniqid}";  // 表示当前订单，被当前用户抢到了
        // do something ... 主要是模拟用户抢到单后可能要进行的一些密集运算
        $rand  = rand(100, 1000000);
        $sum = 0;
        for ($i = 0; $i < $rand; $i++) {$sum += $i;}
      // redis 事务
        $redis->multi();
        $redis->lPush(&#39;uniqids&#39;, $value);
        $redis->decr(&#39;rest_count&#39;);
        $replies = $redis->exec();  // 执行以上 redis 事务
      // 如果 rest_count 的值被其它的并发进程更改了，以上事务将回滚
        if (!$replies) {
            echo "订单 {$value} 回滚" . PHP_EOL;
        }
    }
    $redis->unwatch();
});
$http->start();

Use ab test

$ ab -t 20 -c 10 http://192.168.1.104:9509/

2. Use file exclusive lock (blocking mode)

Blocking mode If a process acquires a file exclusive lock while other processes are occupying the lock, the process will hang and wait for other processes to release the lock, and then acquire the lock itself before continuing.

Sample code:

<?php
$http = new swoole_http_server("0.0.0.0", 9510);
$http->set(array(
    &#39;reactor_num&#39; => 2,  //reactor thread num
    &#39;worker_num&#39; => 4    //worker process num
));
$http->on(&#39;request&#39;, function (swoole_http_request $request, swoole_http_response $response) {
    $uniqid = uniqid(&#39;uid-&#39;, TRUE);
    $redis = new Redis();
    $redis->connect(&#39;127.0.0.1&#39;, 6379);
    $fp = fopen("lock.txt", "w+");
    // 阻塞(等待)模式， 要取得独占锁定（写入的程序）
    if (flock($fp,LOCK_EX)) {  //锁定当前指针
      // 成功取得锁后，放心处理订单
        $rest_count = intval($redis->get("rest_count"));
        $value = "{$rest_count}-{$uniqid}";
        if ($rest_count > 0) {
            // do something ...
            $rand = rand(100, 1000000);
            $sum = 0;
            for ($i = 0; $i < $rand; $i++) {$sum += $i;}
            $redis->lPush(&#39;uniqids&#39;, $value);
            $redis->decr(&#39;rest_count&#39;);
        }
      // 订单处理完成后，再释放锁
        flock($fp, LOCK_UN);
    }
    fclose($fp);
});
$http->start();

Use ab test

$ ab -t 20 -c 10 http://192.168.1.104:9510/

3. Use file exclusive lock (non-blocking mode)

Non In blocking mode, if a process acquires a file exclusive lock while other processes are occupying the lock, the process will immediately determine that acquiring the lock failed and continue execution. \

Sample code:

<?php
$http = new swoole_http_server("0.0.0.0", 9511);
$http->set(array(
    &#39;reactor_num&#39; => 2,  //reactor thread num
    &#39;worker_num&#39; => 4    //worker process num
));
$http->on(&#39;request&#39;, function (swoole_http_request $request, swoole_http_response $response) {
    $uniqid = uniqid(&#39;uid-&#39;, TRUE);
    $redis = new Redis();
    $redis->connect(&#39;127.0.0.1&#39;, 6379);
    $fp = fopen("lock.txt", "w+");
    // 非阻塞模式， 如果不希望 flock() 在锁定时堵塞，则给 lock 加上 LOCK_NB
    if(flock($fp,LOCK_EX | LOCK_NB))   //锁定当前指针
    {
      // 成功取得锁后，放心处理订单
        $rest_count = intval($redis->get("rest_count"));
        $value = "{$rest_count}-{$uniqid}";
        if($rest_count > 0){
            // do something ...
            $rand  = rand(100, 1000000);
            $sum=0;
            for ($i=0;$i<$rand;$i++){ $sum+=$i; }
            $redis->lPush(&#39;uniqids&#39;, $value);
            $redis->decr(&#39;rest_count&#39;);
        }
      // 订单处理完成后，再释放锁
        flock($fp,LOCK_UN);
    } else {
      // 如果获取锁失败，马上进入这里执行
        echo "{$uniqid} - 系统繁忙，请稍后再试".PHP_EOL;
    }
    fclose($fp);
});
$http->start();

Use ab test

$ ab -t 20 -c 10 http://192.168.1.104:9511/

Finally, the test result comparison of the three processing methods is given

redis transaction method:

......
Concurrency Level:      10
Time taken for tests:   20.005 seconds
Complete requests:      17537
Failed requests:        0
Total transferred:      2578380 bytes
HTML transferred:       0 bytes
Requests per second:    876.62 [#/sec] (mean)
Time per request:       11.407 [ms] (mean)
Time per request:       1.141 [ms] (mean, across all concurrent requests)
Transfer rate:          125.86 [Kbytes/sec] received
......

File exclusive lock (blocking mode):

......
Concurrency Level:      10
Time taken for tests:   20.003 seconds
Complete requests:      8205
Failed requests:        0
Total transferred:      1206282 bytes
HTML transferred:       0 bytes
Requests per second:    410.19 [#/sec] (mean)
Time per request:       24.379 [ms] (mean)
Time per request:       2.438 [ms] (mean, across all concurrent requests)
Transfer rate:          58.89 [Kbytes/sec] received
......

File exclusive lock (non-blocking mode):

......
Concurrency Level:      10
Time taken for tests:   20.002 seconds
Complete requests:      8616
Failed requests:        0
Total transferred:      1266846 bytes
HTML transferred:       0 bytes
Requests per second:    430.77 [#/sec] (mean)
Time per request:       23.214 [ms] (mean)
Time per request:       2.321 [ms] (mean, across all concurrent requests)
Transfer rate:          61.85 [Kbytes/sec] received
......

After comparing the test results, the redis transaction method is better than the file exclusive lock method , and in the file exclusive locking mode, the non-blocking mode is better than the blocking mode.

Recommended tutorial: "PHP Tutorial"

The above is the detailed content of 3 Solutions for PHP Concurrency Scenarios. For more information, please follow other related articles on the PHP Chinese website!