Nodejs监控事件循环异常示例详解

开场白

最近在学习 libuv，也了解了一些 node.js 中使用 libuv 的例子。当然，这篇文章不会去介绍 event loop，毕竟这些东西在各个论坛、技术圈里都被介绍烂了。本文介绍如何正确使用 event loop，以及即使发现程序是否异常 block。

基础

event loop 的基础想必各位读者都比较熟悉了。这里我引用官方的图，简单介绍两句，作为前置准备：

event loop是作为单线程实现异步的方式之一。简而言之，就是在一个大的 while 循环中不断遍历这些 phase，执行对应的 callbacks。这样才实现了真正的异步调用：调用时不必等着响应，等调用的资源准备好了，回调我。
以上就是基础，接下来进入正题：

问题提出

开门见山，我们提出以下问题：

1. js 既然是单线程，那么总有办法 block 住整个程序，虽然用了 libuv，也可能会 block 住主程序。对吗？
2. 如何知道我们的程序 block 住了？

对于问题1，答案是肯定的。任何 io 密集计算都会 block 主进程，调用任何耗时的同步系统 api（比如同步读取大文件等），也会 block。

对于第2个问题，就需要对 libuv 有个基本认识了（想想我前面说的一个大 while）。event loop 既然是 loop，那么总有循环的概念吧？想到循环，能联想到循环次数吧？对~解决方案就是使用循环次数。

方案

这里我提一个思路（并不是说不写代码????）：如果我们正常逻辑下，一秒钟能进行100w 次事件循环（数据基于我本机），那么如果有一段时间，我得到的1秒钟时间循环次数只有50w，那么是不是说明程序中有哪些地方稍微 block 住了？或者夸张地说，由正常的100w 次变为了个数次。这就很严重了。因此及时监控event loop 非常重要。

第一版代码

// 环境准备
const http = require('http');
const path = require('path');
const {execfile, execfilesync} = require('child_process');

const max = 9999;
const getcomputedvaluefromchildprocess = (max) => execfilesync('node', [path.join(__dirname, './childprocess.js'), max]);

http.createserver((req, res) => {
 const k = getcomputedvaluefromchildprocess(max);
 res.write('origin-text: ' + k);
 res.end();
}).listen(8888);


// 第一版实现
const ms_multi = 1000 * 1000;
const blockdelta = 10 * ms_multi;
let start;
function meature() {
 start = process.hrtime();
 setimmediate(function() {
  let seconds;
  [seconds, start] = process.hrtime(start);
  if (seconds * 1000 * ms_multi + start > blockdelta) {
   console.log(`node.eventloop_blocked for ${seconds}secs and ${(start / ms_multi).tofixed(2)}ms.`);
  }
  meature();
 });
}
meature();

// childprocess.js 文件
#!/use/env node
const args = number(process.argv[2]);
function computeio(args) {
 let k;
 for (let i = 0; i < args; ++i) {
  for (let j = 0; j < args; ++j) {
   k = i + j;
  } 
 }
 return k;
}
console.log(computeio(args));

大环境是一个 web 服务器。我们选用了 check 这个 phase 来作为一个起点（这里不使用 timer phase的原因是，settimeout 的 timeout 最低是1ms，在 event loop 空转时，1ms 可以跑好多好多次循环了，本机数据大概是100k次/ms）。应用一开始就调用 meature 方法开始暴力测试。旨在测试这次 check 到下次 check 的时间是否大于10ms：

# 没有请求前
# 等了很久出现一个15ms
➜ test node blocked.js
node.eventloop_blocked for 0secs and 15.71ms.

# 当我执行几次
curl http://localhost:8888
# 出现：
node.eventloop_blocked for 0secs and 175.60ms.
node.eventloop_blocked for 0secs and 149.92ms.
node.eventloop_blocked for 0secs and 147.25ms.

是的，基本雏形出来了。可以根据这些数值进行数据上报、排查问题等。但是！

如果读者有尝试了上面这个例子的话，会发现一个问题：电脑发烫，风扇不停转！

我看了任务管理器，发现 node 进程的 cpu 占用率是100%左右！当我把 meature 逻辑注释掉，cpu 占用率恢复到了0%左右。看来这个版本不行。我们来修改一下~具体原因是不断地执行 setimmediate 代码，不断添加 callback，导致 cpu 一直 run！

第二版代码

我们增加一个采样的概念：每10秒，采样一个至少2秒的循环数（为什么是至少2秒？因为 settimeout 的 timeout 的定义本来也就是至少鸭，哈哈哈哈????）

const every_sec_min_loops = 1000000; // 定义每秒最小循环数
let times = 0; // 一次采样中的循环数
let nowshowincreasetimes = false; // 当前是否应该增加 times
let start = date.now();
const cd = 10 * 1000; // 间隔
function meature(callback = () => {}) {
 settimeout(function() {
  start = date.now();
  nowshowincreasetimes = true;
  _inter();
  settimeout(() => {
   endmeature();
   meature(); // 开始预约下次采样
  }, 2000);
 }, cd);
}
function _inter() {
 setimmediate(() => {
  if (nowshowincreasetimes) {
   ++times;
   return _inter();
  }
 });
}

function endmeature() {
 
 const now = date.now();
 nowshowincreasetimes = false;
 const totalmsspan = now - start;
 const everysecloops = (times / (totalmsspan / 1000)).tofixed(0);
 if (everysecloops < every_sec_min_loops) {
  console.log(`当前每秒循环数${everysecloops}`);
 }
 times = 0;
 return everysecloops
}
meature();

测试结果：

# 当我不断：
curl
# 出现
➜  test node blocked.js
当前每秒循环数777574
当前每秒循环数890565
# 当我们搞事情时：
ab -c 10 -n 200

# 结果是这样的：
➜  test node blocked.js
当前每秒循环数843594
当前每秒循环数913329
当前每秒循环数2
当前每秒循环数2

修改为了第2版后，电脑不再烫了，风扇不再转了。cpu 只有在采样时会上升到30、40样子，不错。

但同时也发现了问题：一秒才2次循环！！这时基本处于拉闸了。为什么呢？

因为我们的请求处理是同步的！同步地生成一个子进程，并且等到子进程运行完了，才把结果返回。可见，在 server 项目中启用耗时的同步操作，风险是多么大！！

我们把同步换为异步试试：

// non-blocked.js
const max = 9999;
const getcomputedvaluefromchildprocess = (max) => new promise((res, rej) => {
 execfile('node', [path.join(__dirname, './childprocess.js'), max], (err, stdout) => {
  const valuefromchildprocess = number(stdout);
  res(valuefromchildprocess);
 });
});

http.createserver(async (req, res) => {
 const k = await getcomputedvaluefromchildprocess(max);
 res.write('origin-text: ' + k);
 res.end();
}).listen(8888);

ps: 为了示范同步、异步的区别，本文用的是子进程这种方式。其实更好的应该是用 worker_thread 的方式、或者分片计算等。让我们用相同的 ab 进行测试，得到结果：

➜  test node non-blocked.js
当前每秒循环数239920
当前每秒循环数242286

可以看到，虽然比空转时的100w同样低了不是一点点。但相对于同步的方式，这个数量级简直不能对比！！

总结

到现在，大家应该对监控 event loop 有个基本认识了。本来想搞一个 npm 包的，但最近比较忙，只能先抛砖，大家有玉的使劲砸。????????????

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。