Introduction to non-blocking methods in NodeJs_javascript skills

First we use NodeJs to build a basic server.
index.js

Copy code The code is as follows:

var requestHandler = require(" ./requestHandler");
var server = require("./server");
var route = {
"/hello": requestHandler.hello,
"/upload": requestHandler. upload
};
server.start(route);

server.js

Copy code The code is as follows:

server.js

Copy code The code is as follows:

var http = require("http");
var url = require("url");
exports.start = function(route) {
var server = http.createServer(function(req, res) {
var pathName = url.parse(req.url).pathname;
var handler = route[pathName];
if (handler) {
console.log("Through path:" pathName ":" new Date().getTime());
handler(res);
} else {
res.writeHead(404, {"Content-Type": "text/plain"});
res.end();
}
});
server.listen(8088);
};

requestHandler.js

Copy code The code is as follows:

exports .hello = function(res) {
res.writeHead(200, {"Content-Type": "text/plain"});
res.write("say hello.");
res .end();
};
exports.upload = function(res) {
res.writeHead(200, {"Content-Type": "text/plain"});
res .write("upload");
res.end();
};

In cmd, type node index.js to start.
However, the above code is blocking. If there is a long-term calculation in the callback function of createServer. Then it will block the event polling of node.js.
In NodeJS, the key to its efficiency lies in quickly returning to the event loop.
We modified requestHandler.js as follows. In this example, because the event loop has been blocked by the sleep function, the callback of createServer cannot return in time.

Copy code The code is as follows:

function sleep(milliSecond) {
var startTime = new Date().getTime();
console.log(startTime);
while(new Date().getTime() <= milliSecond startTime) {
}
console.log( new Date().getTime());
}
exports.hello = function(res) {
sleep(20000);
res.writeHead(200, {"Content-Type": "text/plain"});
res.write("say hello.");
res.end();
};
exports.upload = function(res) {
res.writeHead(200, {"Content-Type": "text/plain"});
res.write("upload");
res.end();
};

Then type http://localhost:8088/hello first, then type http://localhost:8088/upload. You will find that although upload does not take much time, it does have to wait until hello is completed.
We are trying to find a way to call asynchronously. For example, uploading in formidable has been tested to be non-blocking. Looking at the source code of formidable, I found that the most critical thing is the following code:

Copy the code The code is as follows:

IncomingForm.prototype.parse = function(req, cb) {
this.pause = function() {
try {
req.pause();
} catch (err) {
// the stream was destroyed
if (!this.ended) {
// before it was completed, crash & burn
this._error(err);
}
return false;
}
return true;
};
this.resume = function() {
try {
req.resume();
} catch (err) {
// the stream was destroyed
if (!this.ended) {
// before it was completed, crash & burn
this._error(err);
}
return false;
}
return true;
};
this.writeHeaders(req.headers);
var self = this;
req
.on('error', function(err) {
self._error(err);
})
.on('aborted', function() {
self.emit('aborted');
})
.on('data', function(buffer) {
self.write(buffer);
})
.on('end', function() {
if (self.error) {
return;
}
var err = self._parser.end();
if (err) {
self._error(err);
}
});
if (cb) {
var fields = {}, files = {};
this
.on('field', function(name, value) {
fields[name] = value;
})
.on('file', function(name, file) {
files[name] = file;
})
.on('error', function(err) {
cb(err, fields, files);
})
.on('end', function() {
cb(null, fields, files);
});
}
return this;
};

在parse中，将head信息解析出来这段是阻塞的。但是真正上传文件却是在req.on(data)中，是利用了事件驱动，是非阻塞的。也就是说，他的非阻塞模型依赖整个nodeJS事件分派架构。
那么像sleep那样消耗大量计算，但是又不能依赖nodeJS分派架构的时候怎么办？
现在介绍一种，类似于html5 WebWorker的方法。
将requestHandler.js改造如下：

复制代码 代码如下:

var childProcess = require("child_process");
exports.hello = function(res) {
var n = childProcess.fork(__dirname "/subProcess.js");
n.on('message', function() {
res.writeHead(200, {"Content-Type": "text/plain"});
res.write("say hello.");
res.end();
});
n.send({});
};
exports.upload = function(res) {
res.writeHead(200, {"Content-Type": "text/plain"});
res.write("upload");
res.end();
};

并加入subProcess.js

复制代码 代码如下:

function sleep(milliSecond) {
var startTime = new Date().getTime();
console.log(startTime);
while(new Date().getTime() <= milliSecond startTime) {
}
console.log(new Date().getTime());
}
process.on('message', function() {
sleep(20000);
process.send({});
});

测试，当hello还在等待时，upload已经返回。
结语：
大概在最近，我看了博客园上的很多NodeJs文章，大家都认为NodeJS是异步的。但是是何种程度的异步，这个概念就没有几篇文章讲对了。
其实NodeJS，他是一个双层的架构。C ，和javascript。并且是单线程的。这点尤其重要。Node其实是C 利用v8调用js命令，为了实现调用顺序维护了一个Event序列。因此，在一个js function内部，他的调用绝对会对其他的function产生阻塞。所以，网上所说的process.nextTick和setTimeout等，都不能够产生新的线程，以保证不被阻塞。他所实现的，不过是Event序列的元素顺序问题。 相对于setTimeout，process.nextTick的实现要简单的多，直接加入Event序列的最顶层(有个啥啥事件)。而setTimeout是增加了一个c 线程，在指定的时间将callback加入Event序列
以Node的file io为例。他的readFile等函数，第二个参数是一个callback。那么node中第一件事就是记录下callback，然后调用底层c ，调用c 开始的过程，你可以看成是异步的。因为那已经到了c ，而不是js这块。所以，exec到callback为止是异步的，http.createServer到触发callback为止是异步的。还有很多，比如mysql的调用方法，不知道大家有没有看过源码，他就是socket发送命令，相信这个过程速度非常快。然后等待回调的过程Node用c 隐藏了，他也是异步的。
而我这篇文章想说明的是，如果再js端有花费大量时间的运算怎么办。就用我上面所说的方法，用js打开c 的线程，这个subprocess.js，不在node的event序列内部维护。是新的线程，因此不会阻塞其他的js function