Example of implementing sleep function in nodejs_node.js

The most unpleasant thing about nodejs is its single-threaded nature. It cannot do many things, and its performance is not strong enough for CPU-intensive scenarios. For a long time, I have wanted to find some solutions under the JavaScript language framework to solve the problems of inability to operate threads and poor performance. The solution that impressed me the most was fibers, but regardless of fibers or other solutions, thread operation is still very awkward. It relies too much on auxiliary threads and puts the cart before the horse; as far as fibers are concerned, JavaScript is inherently The low performance problem cannot be solved; the most awkward thing is that under the JavaScript language framework, message passing between threads is often very limited, and objects cannot be truly shared.

The addon method of nodejs is undoubtedly excellent, with extremely strong flexibility, complete functions and the performance of native code. Simply put, it allows nodejs to directly call the c/c module, which is a mixed development mode of javascript and native. It’s a good thing, why not use it? Addon should be considered a big topic. I don’t want to talk about it too deeply today. I don’t have much practice myself. Then implement a sleep function and think of it as an introduction.

sleep

Why can’t JavaScript implement real sleep? The sleep method registers a signal with the operating system kernel and sends a wake-up signal after a specified time, while the thread itself hangs. Essentially, when the thread sleep(1000) means telling the operating system: Do not allocate CPU time to me within 1000ms. Therefore, sleep can ensure that the thread no longer takes up CPU resources when it is suspended. JavaScript runs in a single thread and cancels the concept of threads. Naturally, there is no way to suspend and interrupt the main thread.

Some people will also try to use javascript to implement sleep, for example:

Copy code The code is as follows:

function sleep(sleepTime) {
for(var start = new Date; new Date - start <= sleepTime; ) { }
}

This uses an empty loop to block the running of the main process to implement sleep, which is obviously far from real sleep.

So what if we implement a real sleep?

Environment preparation

Development environment

Some of my blogs have said it before, so I will omit it here: node.js npm, python 2.7, visual studio/x-code.

Compilation Tools

The compilation tool needs to use node-gyp. Newer versions of nodejs come with this library. If node-gyp does not come with it, please execute:

Copy code The code is as follows:

npm install -g node-gyp

I don’t have the energy to study the features of gyp. If you are familiar with other compilers such as gcc, it is not ruled out that gyp will have incompatibilities, and the compilation options and switches are also different. It is recommended to rewrite the C code for nodejs. If there are indeed modules that need to be reused, you can consider using the familiar gcc to compile it into a dynamic link library, then write a small amount of code to use the dynamic link library, and then use gyp to compile this part of the code for nodejs use.

Enter the project folder and execute npm init to initialize the project. In order to let nodejs know that we want to make an addon, we need to add in package.json:

Copy code The code is as follows:

"gyp-file": true

If you have used gcc, then you must remember makefile. Similarly, gyp also describes the compilation configuration through a file. This file is binding.gyp, which is a json file that we are very familiar with. gyp is not the focus of our discussion, so binding.gyp will not be explored in depth. We will only focus on the most important configuration items. Here is an example of a simple but complete binding.gyp file:

Copy code The code is as follows:

{
"targets": [
{
"target_name": "hello",
"sources": [ "hello.cc" ],
"include_dirs": [
" ]
}
]
}

Just take a look at the three configuration items involved:

1.target_name: Indicates the output module name.
2.sources: Indicates the source code path that needs to be compiled. This is an array.
3.include_dirs: Indicates the directories to be used during the compilation process. The header files in these directories can be searched in the precompilation directive #include. A rather special way of writing is used here. Instead of giving the path as a string constant, we run a command node -e "require('nan')". We will talk about the nan library later. First, let's take a look at what this command outputs: node_modulesnan, it turns out that this command means to return the path of the nan library.

C encoding

OK, now that the source code is hello.cc has been configured, create such a file. There is a problem that needs to be reminded in advance. The c module we write will eventually be used by the v8 engine, so the API, writing method, etc. are restricted by the v8 engine. Different versions of nodejs actually use different versions of the v8 engine, which means that it is difficult to use a set of c code to satisfy different versions of nodejs (referring to the compilation process. After the compilation is completed, it should be able to be used across versions, without verification. Yes. Github cannot upload binary libraries, so open source on Github will cause trouble. npm can directly upload binary libraries and skip the compilation step, so the problem is relatively minor).

node 0.11 and above:

Copy code The code is as follows:

#include
#include

using namespace v8;

void SleepFunc(const v8::FunctionCallbackInfo& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
double arg0 = args[0] -> NumberValue();
Sleep(arg0);
}

void Init(Handle