带有Restify的Node.js如何处理并发请求？

Question

With the following code:

var counter = 0;
server.get(
    '/test,
    function(request, response, next)
    {
        console.log('Counter', ++counter);
        next();
    }
);

How does the counter variable is affected with several concurrent connections? Restify (or Node) has some kind of connection insolation or a queue of incoming requests?

Many thanks in advance.

Answer 1

Effectively, restify is wrapping one of a few different packages: spdy , http , or https .

if (options.spdy) {
    this.spdy = true;
    this.server = spdy.createServer(options.spdy);
} else if ((options.cert || options.certificate) && options.key) {
    this.ca = options.ca;
    this.certificate = options.certificate || options.cert;
    this.key = options.key;
    this.passphrase = options.passphrase || null;
    this.secure = true;

    this.server = https.createServer({
        ca: self.ca,
        cert: self.certificate,
        key: self.key,
        passphrase: self.passphrase,
        rejectUnauthorized: options.rejectUnauthorized,
        requestCert: options.requestCert,
        ciphers: options.ciphers
    });
} else if (options.httpsServerOptions) {
    this.server = https.createServer(options.httpsServerOptions);
} else {
    this.server = http.createServer();
}

Source: https://github.com/restify/node-restify/blob/5.x/lib/server.js

Those packages manage the asynchronous nature of requests, which are handled as Events within restify . The EventListener calls all listeners synchronously in the order in which they were registered. . In this case, restify is the listener and will process the requests in the order they are received.

Scaling

That being said, web servers like restify are often scaled up by releasing them on multiple processes behind a proxy like nginx . In this case, nginx would be splitting the incoming requests between the processes effectively allowing the web server to handle a larger concurrent load.

Node.js Limitations

Lastly, just keep in mind this is all limited by the behavior of Node.js. Since the app runs on a single thread, you can effectively block all requests while performing a slow synchronous request.

server.get('/test', function(req, res, next) {
    fs.readFileSync('something.txt', ...) // blocks the other requests until done
});