Specifically at the PHP code level, what are the measures to improve high concurrency?

1. I was asked a question today: What are the measures to improve high concurrency at the PHP code level?

When faced with high concurrency issues, the first thing I thought of was clusters and caches (apt, redis, mem, memory...), but when it came to the PHP code level, I couldn't think of anything else besides queues and reducing network requests, so I opened this Discussion post, I hope the master will leave a feasible solution.

Reply content:

1. I was asked a question today: What are the measures to improve high concurrency at the PHP code level?

When faced with high concurrency issues, the first thing I thought of was clusters and caches (apt, redis, mem, memory...), but when it came to the PHP code level, I couldn't think of anything else besides queues and reducing network requests, so I opened this Discussion post, I hope the master will leave a feasible solution.

I think at the code level of PHP, we should start directly from the relevant knowledge points of PHP

• Project’s SESSION processing mechanism, files->DB->Cache

• Project’s Log records the situation, files->DB

• Resource reuse, asynchronous processing of long-term operations, singletons, global data sharing, queues, etc.

• Bytecode cache APC,XCACHE,OPCACHE

• Data (view) cache, file cache (files)->Local cache (Yac)->Distributed cache (MEMCACHE, REDIS)

• Framework selection, micro-framework (Lumen)->Full-stack PHP framework (SF, LARAVEL)->Extended framework (Yaf, Phalcon)->Parallel framework (Yar)

• PHP Version selection, PHP5.x->hhvm->php7

Is this a question during the interview?

It is estimated that I encountered related problems during the actual development of the interview company, so I used them as interview questions

Specifically in terms of code, when it comes to improving concurrency, we can learn from nodejs's ideas, which is asynchronous, non-blocking access to ensure high concurrency, so you can talk about what extensions of asynchronous operations PHP has, such as me After searching, there is an extension called swoole.
Also, more computing tasks are handed over to the front end, reducing server-side calculations and improving response speed.
The other thing is to operate the database. Maybe it would be good to talk about how to modify the organizational form of the database (reduce operations like join)

Only speed will never break!

A request once every 10ms will be 10 times less stressful than a request once every 100ms, because your concurrency is limited. If a connection comes in and is not completed for a long time, resources will be occupied and not released, and it is easy to occur at the same time. A large number of concurrent connections. When the CPU and memory are full, there will be a vicious cycle of stuck, so you need to set an upper limit on the number of connections.

Then, most people have this problem (our company has such code everywhere), unoptimized large data I/O:

<code>// 取用户的订单列表
$orders = api_get_orders($uid);
// 可是, 订单里没有商品的详情, 怎么做呢?
foreach($orders as $i=>$order){
    // api_get_good_by_id 是个缓存或mysql IO
    $orders[$i]['good'] = api_get_good_by_id($order['goodid']);
}
return $orders;</code>

A large amount of IO is generated in the loop. If on average a user receives 20 order data at a time, 10 concurrent requests will generate 200 database/cache IO

Combine them into one IO:

<code>// 取用户的订单列表
$orders = api_get_orders($uid);
// 提取goodid序列
$goodids = array_map(function($o){ return $o['goodid']; }, $orders);
// 一次性把商品全部取出来
$goods = api_get_goods_by_ids( $goodids );
// 封装到$orders
foreach($goods as $i=>$g){
    $orders[$i]["good"] = $g;
}
return $goods;</code>

Cache driver design a layer of runtime cache

Sometimes a large amount of data for the same key is read from the cache. If we add a level of runtime cache and have a cache IO, wouldn't it be faster to get it directly from the PHP variable next time? Similar to what we do in the method Use static to cache some stable data. Of course, don’t forget to encapsulate the cache delete and set, clear or update the runtime cache.

Yes, everything is to reduce IO and improve reuse. It doesn’t make much sense to worry about which algorithm can make sorting faster, except for sql statement optimization

Object resource reuse. For example, singleton mode instantiates a database object. This object is shared
Reduce the IO overhead of data

I also know a little bit about it. I know that if you can make fewer requests to the database, make as few requests as possible. If the stored data is not urgent, put it in redis, and then run scheduled tasks.

Generally, the most feared thing is the update of the same data, such as new inventory. This can be solved by using queues.