文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

编写自己的js运行时第二篇

2024-12-03 02:36

关注

前言：第一版基于V8实现了一个朴素版的服务器，第二版支持了多进程架构，并且支持了SO_REUSEPORT。本文介绍一下第二版的一些实现，设计上还是比较随意的，目前主要关注功能。

首先我们看看第二版怎么使用。

1 通过fork共享端口

  1. const TCPServer = TCP(); 
  2.  
  3. const tcpServer = new TCPServer('127.0.0.1', 8989); 
  4.  
  5. tcpServer.socket(); 
  6. tcpServer.setReusePort(1); 
  7. tcpServer.bind(); 
  8. tcpServer.listen(); 
  9.  
  10. for (let i = 0; i < 3; i++) { 
  11.  
  12.     // 等于0说明是子进程，进入处理连接的逻辑，否则是主进程，循环创建多个进程 
  13.     if (Child_Process.fork() === 0) { 
  14.         while(1) { 
  15.             tcpServer.accept(); 
  16.         }  
  17.     } 
  18.  
  19. } 
  20.  
  21. // 主进程创建完子进程后自己进入阻塞状态 
  22.  
  23. Child_Process.wait(); 

通过fork共享端口版本的原理是主进程首先创建一个socket并且绑定一个端口。然后通过fork的方式让多个子进程共享监听的端口。最后主进程进入阻塞模式。核心实现是fork，我们看看代码。

  1. static Local ChildProcess(Isolate * isolate) { 
  2.   Local target = ObjectTemplate::New(isolate); 
  3.   Local forkName = String::NewFromUtf8(isolate, "fork", NewStringType::kNormal, strlen("fork")).ToLocalChecked(); 
  4.   Local waitName = String::NewFromUtf8(isolate, "wait", NewStringType::kNormal, strlen("wait")).ToLocalChecked(); 
  5.  
  6.   target->Set(forkName, FunctionTemplate::New(isolate, Child_Process::Fork)); 
  7.   target->Set(waitName, FunctionTemplate::New(isolate, Child_Process::Wait)); 
  8.   Local obj; 
  9.   bool ignore = target->NewInstance(isolate->GetCurrentContext()).ToLocal(&obj); 
  10.   return obj; 
  11.  
  12. } 
    13. 

    第二版加入了进程模块，上面的代码定义了进程模块的功能。然后注入到全局变量，No.js目前的设计中，每个模块是一个全局变量，和我们使用Object、Array一样，不像Node.js的C++模块是链成一条链表。
    

    

    1. // 模块名称 
    2. Local child_process_name = String::NewFromUtf8(isolate, "Child_Process",  strlen("Child_Process")).ToLocalChecked();// 注册全局变量 
    3. global->Set(context, child_process_name, ChildProcess(isolate)); 
    

    这样就完成了模块的注入，在JS层就可以使用了。下面我们看看具体的实现。
    

    

    1. class Child_Process { 
    2.     public: 
    3.  
    4.         static void Fork(const FunctionCallbackInfo& info) { 
    5.             info.GetReturnValue().Set(Number::New(info.GetIsolate(), fork())); 
    6.         } 
    7.  
    8.         static void Wait(const FunctionCallbackInfo& info) { 
    9.             int status; 
    10.             wait(&status); 
    11.         } 
    12.  
    13. }; 
    

    实现很简单，只是对fork函数的封装，重点在于对fork函数的理解，  执行fork函数后会创建一个子进程，子进程的fork返回0，主进程返回子进程id，通过这个特性，我们可以写一个if判断处理下一步的逻辑。
    

    2  通过fork+execve+reuserport共享端口
    

    第二种模式是比较复杂且比较高性能的模式，之前的文章介绍过不同服务器架构的实现和优缺点，第一种fork共享端口的模式中，会有惊群和负载不均衡的问题，有兴趣可以参考之前的文章，就不多介绍。接下来看第二种模式的使用(下面代码是execve-server.js)。
    

    1. const TCPServer = TCP(); 
    2.  
    3. const tcpServer = new TCPServer('127.0.0.1', 8989); 
    4.  
    5. tcpServer.socket(); 
    6. tcpServer.setReusePort(1); 
    7. tcpServer.bind(); 
    8. tcpServer.listen(); 
    9.  
    10. const isMaster = Child_Process.getEnv("isMaster") === ""; 
    11.  
    12. if (isMaster) { 
    13.  
    14.     for (let i = 0; i < 3; i++) { 
    15.         Child_Process.execve("./No", "execve-server.js");   
    16.     } 
    17.     Child_Process.wait(); 
    18.  
    19. } else { 
    20.  
    21.     while(1) { 
    22.         tcpServer.accept(); 
    23.     } 
    24.  
    25. } 
    

    我们知道多个进程是不能绑定同一个端口的，第一种模式中通过fork绕过了这个限制，第二版面对并解决了这个问题。上面代码的逻辑看起来也很简单，主进程创建多个子进程，并且在每个子进程里执行同一个文件execve-server.js。然后在execve-server.js中通过环境变量isMaster区分主子进程进行不同的处理，当然也可以执行新的文件。这里是为了提到isMaster这个环境变量。上面代码中，重点是setReusePort和execve，下面我们具体看一下实现。
    

    

    1. static Local ChildProcess(Isolate * isolate) { 
    2.   Local target = ObjectTemplate::New(isolate); 
    3.   Local execveName = String::NewFromUtf8(isolate, "execve", NewStringType::kNormal, strlen("execve")).ToLocalChecked(); 
    4.   Local getEnvName = String::NewFromUtf8(isolate, "getEnv", NewStringType::kNormal, strlen("getEnv")).ToLocalChecked(); 
    5.  
    6.   target->Set(execveName, FunctionTemplate::New(isolate, Child_Process::Execve)); 
    7.   target->Set(getEnvName, FunctionTemplate::New(isolate, Child_Process::GetEnv)); 
    8.   Local obj; 
    9.   bool ignore = target->NewInstance(isolate->GetCurrentContext()).ToLocal(&obj); 
    10.   return obj; 
    11.  
    12. } 
      13. 

      同样，先定义入口使得JS可以调用。另外给TCP模块定义了一个新接口setReusePort。
      

      1. SetProtoMethod(isolate, TCPServer, "setReusePort", TCPServer::TCPServerSetUserPort); 
      

      接下来看底层的实现，首先看TCPServerSetUserPort的实现。
      

      

      1. static void TCPServerSetUserPort(const FunctionCallbackInfo& info) { 
      2.     int on = info[0].As()->Value(); 
      3.     GetTCPServer(info.Holder())->Setsockopt(SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); 
      4.  
      5. } 
      6.  
      7.  
      8.  
      9. int Setsockopt(int level, int optionName, const void *optionValue, socklen_t option_len) { 
      10.  
      11.     return setsockopt(listerFd, level, optionName, optionValue, option_len); 
      12.  
      13. } 
      

      简单地对setsockopt的封装，没有太多需要讲的。下面看环境变量和execve的逻辑。
      

      

      1. class Child_Process { 
      2.     public: 
      3.  
      4.         static void GetEnv(const FunctionCallbackInfo& info) { 
      5.             String::Utf8Value key(info.GetIsolate(), info[0]); 
      6.             char * value = getenv(*key); 
      7.             // Logger::log(value); 
      8.             Local str = String::NewFromUtf8(info.GetIsolate(), value, NewStringType::kNormal, strlen(value)).ToLocalChecked(); 
      9.             info.GetReturnValue().Set(str); 
      10.         } 
      11.  
      12.         static void Execve(const FunctionCallbackInfo& info) { 
      13.             int length = info.Length(); 
      14.             char** args = new char*[length + 1]; 
      15.             int i = 0; 
      16.             for (i = 0; i < length; i++) { 
      17.                 String::Utf8Value arg(info.GetIsolate(), info[i]); 
      18.                 args[i] = strdup(*arg); 
      19.             } 
      20.             args[i] = NULL; 
      21.             char *env[] = { "isMaster=0", NULL }; 
      22.             // int fd[2]; 
      23.             // socketpair(AF_UNIX, SOCK_STREAM, 0, fd); 
      24.  
      25.             int pid = fork(); 
      26.             if (pid == 0) { 
      27.                 // close(fd[0]); 
      28.                 execve(args[0], args, env); 
      29.                 // execve会加载可执行文件，从新的入口开始执行，执行到这说明execve出错了 
      30.                 write(1, strerror(errno), sizeof(strerror(errno))); 
      31.                 exit(-1); 
      32.             } 
      33.             // close(fd[1]); 
      34.             if (args) { 
      35.                 for (int i = 0; i < length && args[i]; i++) { 
      36.                     free(args[i]); 
      37.                 } 
      38.                 delete [] args; 
      39.             } 
      40.         } 
      41.  
      42. }; 
      

      目前只实现了获取环境变量的逻辑，主要是对getenv的封装。execve的代码看起来很多，主要是参数的处理，我们只需要关注下面的代码。
      

      1. int pid = fork(); 
      2.  // 子进程重新加载新的可执行文件 
      3.  if (pid == 0) { 
      4.      // close(fd[0]); 
      5.      execve(args[0], args, env); 
      6.      // execve会加载可执行文件，从新的入口开始执行，执行到这说明execve出错了 
      7.      write(1, strerror(errno), sizeof(strerror(errno))); 
      8.      exit(-1); 
      9.  } 
      

      首先通过fork创建一个子进程，然后通过execve加载要执行的代码(这里是./No  execve-server.js)。重点是execve函数会重新加载可执行文件，然后从新的地址(可执行文件中指定)开始执行，所以我们看到execve后是不需要return的，因为下面的代码不会执行了，除非execve执行出错了，这里我们打印错误信息然后退出进程。第二种模式的好处就是我们可以随意在多个js文件中绑定同一个端口而不会报错，这得益于SO_REUSEPORT的特性。SO_REUSEPORT让每个进程对应一个连接队列，解决了惊群问题，并且内核负责连接分发的复杂均衡，不仅提高了性能，同时使得应用程序变得简单。
      

      3 和Node.js相比
      

      Node.js的进程是通过fork+execve实现的，Cluster模块基于进程模块实现了多进程架构，主要有两种模式：轮询和共享，轮询就是主进程接收连接分发给子进程处理，子进程不接收连接只负责处理业务逻辑。这种模式的好处是没有惊群现象，但是主进程的能力会成为服务器的瓶颈，共享模式和本文的第一种一样，多个子进程共享一个端口，但是实现不一样，本文是主进程创建socket通过fork子进程共享，Node.js是主进程创建socket通过文件描述符的方式传递给子进程，不过殊途同归，主要是让多个子进程共享监听socket。本文的第二种模式，目前Node.js还不支持，因为SO_REUSEPORT是比较新的特性，但是对性能提升非常大。
      

      后记：以上就是第二版新增的功能，我们已经具备了一个可以处理请求的多进程架构服务器，但是目前还是单进程里串行处理请求的，我们还需要很多东西，文件、IPC、事件驱动模块、HTTP解析器等等，后续会考虑把最近写的Node.js  io_uring  Addon合进来。最近把头文件和V8静态库都打包了，有兴趣的同学可以自行编译运行https://github.com/theanarkh/No.js。
      



       
      来源：编程杂技内容投诉
      免责声明：
      ① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。 
      ② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
      软考中级精品资料免费领 
      • 历年真题答案解析
      • 备考技巧名师总结
      • 高频考点精准押题
      • 资料下载
      • 历年真题
      • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）
         难度      813人已做 
         查看 
      • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析
         难度      354人已做 
         查看 
      • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析
         难度      318人已做 
         查看 
      • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）
         难度      435人已做 
         查看 
      • 2024年上半年系统架构设计师考试综合知识真题
         难度      224人已做 
         查看 
      相关文章
      发现更多好内容
      猜你喜欢
      AI推送时光机
      编写自己的js运行时第二篇
      后端开发Node.js2024-12-03
      java如何运行自己编写的程序文件
      后端开发2023-09-28
       位置：首页-资讯-后端开发
       咦！没有更多了？去看看其它编程学习网 内容吧 
      首页课程
      资料下载      问答资讯