Question

I'm quite new to nodejs and I'm doing some experiments. What I get from them (and I hope I'm wrong!) is that nodejs couldn't serve many concurrent requests for the same resource without putting them in sequence.

Consider following code (I use Express framework in the following example):

var express = require('express');
var app = express();

app.get('/otherURL', function (req, res) {
res.send('otherURL!');
});

app.get('/slowfasturl', function (req, res) 
{

    var test = Math.round(Math.random());

    if(test == "0")
    {
        var i;
        setTimeout
        (
            function()
            {
                res.send('slow!');

            }, 10000
        );

    }
    else
    {
        res.send('fast!');
    }

});

app.listen(3000, function () {
      console.log('app listening on port 3000!');
    });

The piece of code above exposes two endpoints:

http://127.0.0.1:3000/otherurl , that just reply with "otherURL!" simple text
http://127.0.0.1:3000/slowfasturl , that randomly follow one of the two behaviors below:

scenario 1 : reply immediately with "fast!" simple text

or

scenario 2 : reply after 10 seconds with "slow!" simple text

My test: I've opened several windows of chrome calling at the same time the slowfasturl URL and I've noticed that the first request that falls in the "scenario 2", causes the blocking of all the other requests fired subsequentely (with other windows of chrome), indipendently of the fact that these ones are fallen into "scenario 1" (and so return "slow!") or "scenario 2" (and so return "fast!"). The requests are blocked at least until the first one (the one falling in the "scenario 2") is not completed.

How do you explain this behavior? Are all the requests made to the same resource served in sequence?

I experience a different behavior if while the request fallen in the "scenario 2" is waiting for the response, a second request is done to another resource (e.g. the otherurl URL explained above). In this case the second request is completed immediately without waiting for the first one

thank you

Davide

Answer 1

As far as I remember, the requests are blocked browser side.

Your browser is preventing those parallel requests but your server can process them. Try in different browsers or using curl and it should work.

Answer 2

您观察到的行为只能通过浏览器执行的任何排序来解释。 Node不按顺序处理请求，而是使用事件驱动模型，利用libuv framework
我已经使用非浏览器客户端运行了测试用例，并确认请求不会相互影响。

为了获得进一步的证据，我建议如下：

隔离问题范围。删除express（http抽象）并使用http（base http impl），甚至net（TCP）模块。
使用非浏览器客户端。我建议ab（如果你在Linux中） - apache基准测试工具，专门用于web服务器性能测量。我用了

ab -t 60 -c 100 http://127.0.0.1:3000/slowfasturl

为100个并发客户端收集数据60秒。
1. 通过用计数器替换Math.random，并在巨大超时和小超时之间切换，使其更具确定性。
2. 检查结果以查看慢速和快速响应的速率和模式。

希望这有帮助。

Answer 3

Davide: This question needs an elaboration, so adding as another answer rather than comment, which has space constraints.

If you are hinting at the current node model as a problem:

Traditional languages (and runtimes) caused code to be run in sequence. Threads were used to scale this but has side effects such as: i) shared data access need sequencing, ii) I/O operations block. Node is the result of a careful integration between three entities libuv(multiplexer), v8 (executor), and node (orchestrator) to address those issues. This model ensures improved performance and scalability under web and cloud deployments. So there is no problem with this approach.

If you are hinting at further improvements to manage stressful CPU bound operations in node where there will be waiting period yes, leveraging the multi-core and introducing more threads to share the CPU intensive workload would be the right way.

Hope this helps.

nodejs multithread for the same resource

3 个答案: