精华 从No.js看Node.js原理
发布于 3 个月前 作者 theanarkh 4297 次浏览 来自 分享

前言:越来越多同学在使用Node.js,大家也不同程度地理解Node.js是什么。比如Node.js是由V8、Libuv、JS组成的,Node.js底层是C\C++,Node.js不是语言是运行时。本文通过实现一个类Node.js的JS运行时No.js,去理解Node.js的本质。No.js是我之前写的一个JS运行时,概念上是这么说,但是它算不上真正的运行时,它只是个demo,但是它让你看到如果你有兴趣,你也可以写个Node.js。

首先我们看看V8的基本用法。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "include/libplatform/libplatform.h"
#include "include/v8.h"

int main(int argc, char* argv[]) {
  // Initialize V8.
  v8::V8::InitializeICUDefaultLocation(argv[0]);
  v8::V8::InitializeExternalStartupData(argv[0]);
  std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
  v8::V8::InitializePlatform(platform.get());
  v8::V8::Initialize();

  v8::Isolate::CreateParams create_params;
  create_params.array_buffer_allocator =
      v8::ArrayBuffer::Allocator::NewDefaultAllocator();
  // 创建一个Isolate,表示一个隔离的实例
  v8::Isolate* isolate = v8::Isolate::New(create_params);
  {
    v8::Isolate::Scope isolate_scope(isolate);
    // 定义一个HandleScope 管理下面的handle内存的分配和释放
    v8::HandleScope handle_scope(isolate);
    // 创建一个上下文,js里访问的东西来自context
    v8::Local<v8::Context> context = v8::Context::New(isolate);
    v8::Context::Scope context_scope(context);
	// 定义我们要执行的代码
    v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, "'Hello' + ', World!'",v8::NewStringType::kNormal).ToLocalChecked();
	// 编译脚本
    v8::Local<v8::Script> script = v8::Script::Compile(context, source).ToLocalChecked();
	// 执行脚本
    v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
    // 输出结果
    v8::String::Utf8Value utf8(isolate, result);
    printf("%s\n", *utf8);
  }

  // Dispose the isolate and tear down V8.
  isolate->Dispose();
  v8::V8::Dispose();
  v8::V8::ShutdownPlatform();
  delete create_params.array_buffer_allocator;
  return 0;
}

我们看代码很多,但是大部分的根据V8文档就行,最核心的是context和脚本的定义,我们看到这里的context是V8提供的内容,然后执行的JS脚本也平平无奇。下面我们要做的事情就是拓展这个context,给他注入一下新功能,相应地,在JS里也就能访问V8内置变量之外的变量,我们看看怎么搞。

	  // 拿到一个全局变量,这个就是我们在js里对应的全局变量
      Local<Object> global =  context->Global();
      // 定义一个字符串对象
      Local<Value> key = String::NewFromUtf8(isolate, "TCP",
                          NewStringType::kNormal,
                          strlen("TCP")).ToLocalChecked();
      Local<Value> cbdata = String::NewFromUtf8(isolate, "dummy",
                          NewStringType::kNormal,
                          strlen("dummy")).ToLocalChecked();
      // 定义一个函数                   
      Local<Function> func = Function::New(context,
                        // 执行func时会调用Invoke,cbdata是入参
                        Invoke,
                        cbdata).ToLocalChecked();   
      // 把函数注册到全局变量,这样我们在js里就可以使用key该函数了                                    
      Maybe<bool> ignore = global->Set(context, key, func);
      // 打开文件
      int fd = open(argv[1], O_RDONLY);
      struct stat info;
      // 取得文件信息
      fstat(fd, &info);
      // 分配内存保存文件内容
      char *ptr = (char *)malloc(info.st_size + 1);
      // 读取文件搭配ptr,Mac os的read函数定义第二个参数是void *
      read(fd, (void *)ptr, info.st_size);
      // 要执行的js代码
      Local<String> source = String::NewFromUtf8(isolate, ptr,
                          NewStringType::kNormal,
                          info.st_size).ToLocalChecked();

上面代码主要分为几个部分。 1 从context中获取全局变量。 2 定义一个新功能,并注入到全局变量,这样我们就可以在JS里访问了。 3 打开一个文件并且读取进来,交给V8编译执行。 下面我们看重点,即我们自定义的功能。从注释里我们看到我们给注入了一个TCP的全局变量。他的值是一个函数。当我们在JS里执行TCP这个函数的时候,就会执行我们自定义的C++函数,并传入实参。我们定义的函数是Invoke,我们看看实现。

static void Invoke(const FunctionCallbackInfo<Value>& info) {
  Isolate * isolate = info.GetIsolate();
  // 新建一个函数模版,模版函数是TCPServer::NewTCPServer
  Local<FunctionTemplate> Server = FunctionTemplate::New(isolate, TCPServer::NewTCPServer);
  Local<String> tcpServerString = String::NewFromUtf8(isolate, "TCPServer", NewStringType::kNormal, strlen("TCPServer")).ToLocalChecked();
  // 函数名
  Server ->SetClassName(tcpServerString);
  // 预留一个指针空间,保存一些自定义的上下文
  Server->InstanceTemplate()->SetInternalFieldCount(1);
  
  // 设置TCPServer的原型方法
  SetProtoMethod(isolate, Server, "socket", TCPServer::TCPServerSocket);
  SetProtoMethod(isolate, Server, "bind", TCPServer::TCPServerBind);
  SetProtoMethod(isolate, Server, "listen", TCPServer::TCPServerListen);
  SetProtoMethod(isolate, Server, "accept", TCPServer::TCPServerAccept);
  //SetProtoMethod(isolate, Server, "setsockopt", TCPServer::TCPServerSetsockopt);
  info.GetReturnValue().Set(Server->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
}

上面代码看起来很复杂,主要是对V8 API的使用。在V8里,我们自定义的函数格式如下

static void func(const FunctionCallbackInfo<Value>& info) {
	info.GetReturnValue().Set(返回值);
}

入参是 FunctionCallbackInfo<Value>,函数的返回值通过info.GetReturnValue().Set函数设置。即我们在JS层拿到的内容。上面代码翻译成JS如下。

function Invoke() {
	return Server;
}

function Server() {
    TCPServer.NewTCPServer(this);
}
Server.prototype.socket = function socket() {
	return this[0].socket();
}


class TCPServer(){
	constructor(target) {
		target[0] = this;
		this.persistent_handle_ = target;
	}
	static NewTCPServer(target) {
		new TCPServer(target);
	}
	
	socket() {}
	bind() {}
	...
}

可以看到,执行Invoke后拿到一个函数TCPServer。然后我们执行new TCPServer,JS代码如下(server.js)

const Server = TCP();
const server = new Server('127.0.0.1', 8989);
server.socket();
server.bind();
server.listen();
while(1) {
    server.accept();
}

当我们执行new Server的时候。V8首先会创建一个对象obj,然后执行TCPServer.NewTCPServer。并传入obj对象。

static void NewTCPServer(const FunctionCallbackInfo<Value>& info) {
   	String::Utf8Value ip_address(info.GetIsolate(), info[0]);
    int port = info[1].As<Uint32>()->Value();
    // info.This()就是obj
    new TCPServer(info.GetIsolate(),info.This(), *ip_address, port);
}
// 在this中保存object,析构C++对象的时候需要重置object[0] 
TCPServer(Isolate* isolate, Local<Object> object, char * ip, int port): _isolate(isolate),persistent_handle_(isolate, object), _ip(ip), _port(port) {
  // obj[0]=this
  object->SetAlignedPointerInInternalField(0, static_cast<void*>(this));
}

NewTCPServer同样创建一个对象this,然后通过obj[0]=this关联起来,这是核心逻辑,一会我们会看到有什么用。接下来我们执行一系列网络编程的函数,不过原理是一样的,我们就分析server.socket()。因为server是一个Server实例。所以server.socket() 对应的函数是Server.prototype.socket。这个函数会从this中取出真正对象(TCPServer实例)的socket函数。然后执行它。

// 执行真正对象的socket函数
static void TCPServerSocket(const FunctionCallbackInfo<Value>& info) {
  GetTCPServer(info.Holder())->Socket();
}
// 取出真正的对象,即obj[0]
static TCPServer * GetTCPServer(Local<Object> object) {
    return reinterpret_cast<TCPServer *>((*reinterpret_cast<v8::Local<Object>*>(&object))->GetAlignedPointerFromInternalField(0));
 }

从中我们可以看到Server函数是一个透传的作用。他主要用于适配V8的协议。真正的逻辑是在它关联的对象中实现的。其余的实现如下。

int Socket() {
    listerFd = socket(AF_INET, SOCK_STREAM, 0);
    return listerFd;
}

int Bind() {    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(_ip);
    serv_addr.sin_port = htons(_port);
    return bind(listerFd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
}

int Listen() {
    return listen(listerFd, 512);
}

int Accept() {
    int clientFd = accept(listerFd, nullptr, nullptr);
    // 返回ok,然后关闭TCP连接
    const char * rsp = "connect ok";
    write(clientFd, rsp, sizeof(rsp));
    close(clientFd);
    return 0;
}

int Setsockopt(int level, int optionName, const void *optionValue, socklen_t option_len) {
    return setsockopt(listerFd, level, optionName, optionValue, option_len);
}

int Close() {
    return close(listerFd);
}

都是对socket网络编程的封装。最后我们通过No server.js启动服务器,全部代码执行完后,最后阻塞在accept。

while(1) {
    server.accept();
}

这时候我们启动客户端。

const net = require('net');

function handle() {
    setTimeout(() => {
        const socket = net.connect({host: '127.0.0.1', port: 8989 });
        socket.on('connect', () => {
            console.log('ok');
            socket.destroy();
            handle();
        });
    }, 1000);
}

handle();

我们会看到不断输出ok,因为一直在断连重连。至此我们通过拓展V8完成了一个服务器的开发。

后记:本文通过拓展V8实现一个简单的朴素版TCP服务器来了如何拓展V8,而Node.js正是用了这种方式。再封装一下操作系统的文件、网络、进程、线程、IPC等等,我们也可以实现一个Node.js。当然,这是理论上。No.js仓库https://github.com/theanarkh/No.js,大家可自行编译

9 回复

605.87MB 除了v8,有没有比较轻量的可以在c++中动态执行js的方案?

@yakczh mujs、quickjs都是很轻量的方案,go语言还有纯go实现的goja

因为我不懂c++,所以我没怎么看懂,这大约只是实现了在js调用c语言函数的功能,任何一个解释器都必定会有与宿主语言通信的功能,因此这并没有什么特别的 很忏愧的事情是我写node也几年了,至今也没有看懂别人写的关于node.js事件循环的内容,原因就是他们根本没有说清楚为什么有事件循环,为什么要事件循环。 我最近在玩lua,我发现lua同样是单线程,它同样可以玩并发的网络通信,但是它用的却是协程而不是回调 js有协程吗?有!但js不叫协程,叫生成器(Generator),是在es6才成为正式标准, es6是2015年才发布,而node诞生在2009年 至于协程实现和回调实现哪个效率高,这个暂时没有研究,虽然协程可以模拟出来,但是如果js早就提供了协程的语法,也许node会走上另一条道路

事件循环不仅仅Node.js里有,Nginx,Redis也有,单线程并且没有协程的情况下,用事件循环是很自然的,如果不用的话,你觉得代码架构是怎样的呢。你提到了js协程,我觉得js只是壳子,重点是Libuv要实现协程。协程可以避免上下文切换。但是Node.js是单线程的,没有什么切换。用协程只是改变了编码方式,是回调还是同步方式而已。这时候系统里就是一堆协程,比如启动了个服务器,调accept发现没有连接,yield一下给epoll所在协程执行。epoll阻塞,连接到来,epoll yield到服务器协程执行。对单线程服务器来讲,高性能并发的核心是epoll。lua大概也是epoll加协程吧,这种就可以同步方式写异步代码了。也不用事件循环了。 以上纯属个人见解。

@theanarkh lua是怎么简单怎么来,解决的是有没有的问题,很粗暴的用select,因为Lua选择用协程来实现单线程的并发,因此它没有出现回调地狱 生成器出现的时候很多人也是用来解决写同步代码的问题,到后面的async/await也是借鉴了协程的概念 我个人认为node原理应该是libuv+事件循环+v8,这里面如果把v8换成lua,那就是node.lua了

@zengming00 回调的解决方案 async await性能是比类似goruntine的协程要好的多多,

回到顶部