Lassen Sie uns über verschiedene Situationen sprechen, die dazu führen können, dass der Node.js-Prozess beendet wird

Dieser Artikel befasst sich mit dem Beenden des Prozesses Node und stellt verschiedene Situationen vor, die zum Beenden des Node.js-Prozesses führen können. Ich hoffe, dass er für alle hilfreich ist!

Nach der Veröffentlichung unseres Dienstes wird er zwangsläufig von der Betriebsumgebung (z. B. Container, PM2 usw.) geplant, Dienst-Upgrades führen zu Neustarts und verschiedene Ausnahmen führen im Allgemeinen zum Absturz des Prozesses. In der Betriebsumgebung gelten Einschränkungen für den Dienstprozess. Wenn der Prozess abnormal ist, gibt es auch eine fortlaufende Upgrade-Strategie. Die Planungsstrategie der laufenden Umgebung behandelt unseren Serviceprozess jedoch als Black Box und kümmert sich nicht um die internen Betriebsbedingungen des Serviceprozesses. Daher muss unser Serviceprozess die Planungsaktionen der laufenden Umgebung aktiv erkennen und dann ausführen einige Bereinigungsaktionen beenden.

Deshalb werden wir heute die verschiedenen Situationen klären, die zum Beenden des Node.js-Prozesses führen können, und was wir tun können, indem wir diese Prozessbeendigungsereignisse abhören.

Prinzip

Ein Prozess muss in zwei Situationen beendet werden: Zum einen, wenn der Prozess von sich aus beendet wird, und zum anderen, wenn er ein Systemsignal empfängt, das den Prozess zum Beenden auffordert.

Systemsignalbenachrichtigung zum Beenden

Allgemeine Systemsignale sind im Node.js offiziellen Dokument aufgeführt. Wir konzentrieren uns hauptsächlich auf einige:

• SIGHUP: Stoppen Sie den Prozess nicht mit Strg+C, sondern schließen Sie ihn es direkt Das Befehlszeilenterminal löst dieses Signal aus
• SIGINT: Wird ausgelöst, wenn Strg + C gedrückt wird, um den Prozess zu stoppen, wenn pm2 den untergeordneten Prozess neu startet oder stoppt. Dieses Signal wird auch an den untergeordneten Prozess gesendet
• SIGTERM: Im Allgemeinen Wird verwendet, um den Prozess zum ordnungsgemäßen Beenden zu benachrichtigen. Wenn k8s beispielsweise einen Pod löscht, sendet es ein SIGTERM-Signal an den Pod. Der Pod kann innerhalb des Timeout-Zeitraums (Standard 30 Sekunden) einige Exit-Reinigungsaktionen durchführen Fenstersystem: Durch Drücken von Strg+Pause wird dieses Signal ausgelöst
• SIGKILL: Der Prozess kann keine Reinigungsaktionen ausführen. Wenn Sie den Befehl kill -9 pid ausführen, empfängt der Prozess dieses Signal. Wenn k8s einen Pod löscht, wenn es länger als 30 Sekunden dauert und der Pod nicht beendet wurde, sendet k8s ein SIGKILL-Signal an den Pod und beendet den Pod-Prozess sofort, wenn pm2 den Prozess neu startet oder stoppt, wenn er länger als 1,6 Sekunden dauert Sekunden und der Prozess wurde nicht beendet, sendet er außerdem ein SIGKILL-Signal
• Wenn ein nicht erzwungenes Exit-Signal empfangen wird, kann der Node.js-Prozess das Exit-Signal abhören und eine benutzerdefinierte Exit-Logik ausführen. Wir haben beispielsweise ein CLI-Tool geschrieben, dessen Ausführung lange dauert. Wenn der Benutzer den Prozess über Strg + C beenden möchte, bevor die Aufgabe abgeschlossen ist, kann er zum Warten aufgefordert werden:

const readline = require('readline');

process.on('SIGINT', () => {
  // 我们通过 readline 来简单地实现命令行里面的交互
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  rl.question('任务还没执行完，确定要退出吗？', answer => {
    if (answer === 'yes') {
      console.log('任务执行中断，退出进程');
      process.exit(0);
    } else {
      console.log('任务继续执行...');
    }
    rl.close();
  });
});



// 模拟一个需要执行 1 分钟的任务
const longTimeTask = () => {
  console.log('task start...');
  setTimeout(() => {
    console.log('task end');
  }, 1000 * 60);
};

longTimeTask();

Der Effekt ist Wie folgt: Jedes Mal, wenn der Benutzer Strg + C drückt, wird der Benutzer aufgefordert:

Während der Codeausführung wird eine nicht behandelte Versprechensablehnung ausgelöst (Node.js v16 führt dazu, dass der Prozess beendet wird). Sie können diese Situation durch den Prozess überwachen .on('unhandledRejection') Situation

Wir wissen, dass pm2 die Wirkung eines Daemon-Prozesses hat . Wenn Ihr Prozess mit einem Fehler beendet wird, wird pm2 Ihren Prozess neu starten. Im
• Cluster-Modus
von js wird der Effekt eines untergeordneten Daemon-Prozesses erreicht:

• const cluster = require('cluster');
  const http = require('http');
  const numCPUs = require('os').cpus().length;
  const process = require('process');
  
  // 主进程代码
  if (cluster.isMaster) {
    console.log(`启动主进程: ${process.pid}`);
    // 根据 cpu 核数，创建工作进程
    for (let i = 0; i < numCPUs; i++) {
      cluster.fork();
    }
    // 监听工作进程退出事件
    cluster.on(&#39;exit&#39;, (worker, code, signal) => {
      console.log(`工作进程 ${worker.process.pid} 退出，错误码: ${code || signal}, 重启中...`);
      // 重启子进程
      cluster.fork();
    });
  }
  
  // 工作进程代码
  if (cluster.isWorker) {
    // 监听未捕获错误事件
    process.on(&#39;uncaughtException&#39;, error => {
      console.log(`工作进程 ${process.pid} 发生错误`, error);
      process.emit(&#39;disconnect&#39;);
      process.exit(1);
    });
    // 创建 web server
    // 各个工作进程都会监听端口 8000（Node.js 内部会做处理，不会导致端口冲突）
    http.createServer((req, res) => {
      res.writeHead(200);
      res.end(&#39;hello world\n&#39;);
    }).listen(8000);
    console.log(`启动工作进程: ${process.pid}`);
  }

  Nach dem Login kopieren
Anwendungspraxis

Oben haben wir verschiedene Situationen analysiert, in denen der Node.js-Prozess beendet wird. Lassen Sie uns nun ein Tool erstellen, das das Beenden des Prozesses überwacht eigene Exit-Logik:

// exit-hook.js
// 保存需要执行的退出任务
const tasks = [];
// 添加退出任务
const addExitTask = fn => tasks.push(fn);
const handleExit = (code, error) => {  
  // ...handleExit 的实现见下面
};
// 监听各种退出事件
process.on('exit', code => handleExit(code));
// 按照 POSIX 的规范，我们用 128 + 信号编号 得到最终的退出码
// 信号编号参考下面的图片，大家可以在 linux 系统下执行 kill -l 查看所有的信号编号
process.on('SIGHUP', () => handleExit(128 + 1));
process.on('SIGINT', () => handleExit(128 + 2));
process.on('SIGTERM', () => handleExit(128 + 15));
// windows 下按下 ctrl+break 的退出信号
process.on('SIGBREAK', () => handleExit(128 + 21));
// 退出码 1 代表未捕获的错误导致进程退出
process.on('uncaughtException', error => handleExit(1, error));
process.on('unhandledRejection', error => handleExit(1, error));

接下来我们要实现真正的进程退出函数 handleExit，因为用户传入的任务函数可能是同步的，也可能是异步的；我们可以借助 process.nextTick 来保证用户的同步代码都已经执行完成，可以简单理解 process.nextTick 会在每个事件循环阶段的同步代码执行完成后执行（理解 process.nextTick）；针对异步任务，我们需要用户调用 callback 来告诉我们异步任务已经执行完成了:

// 标记是否正在退出，避免多次执行
let isExiting = false;
const handleExit = (code, error) => {
  if (isExiting) return;
  isExiting = true;

  // 标记已经执行了退出动作，避免多次调用
  let hasDoExit = fasle;
  const doExit = () => {
      if (hasDoExit) return;
      hasDoExit = true
      process.nextTick(() => process.exit(code))
  }

  // 记录有多少个异步任务
  let asyncTaskCount = 0;
  // 异步任务结束后，用户需要调用的回调
  let ayncTaskCallback = () => {
      process.nextTick(() => {
        asyncTaskCount--
        if (asyncTaskCount === 0) doExit() 
      })
  }
  // 执行所有的退出任务

  tasks.forEach(taskFn => {
      // 如果 taskFn 函数的参数个数大于 1，认为传递了 callback 参数，是一个异步任务
      if (taskFn.length > 1) {
         asyncTaskCount++
         taskFn(error, ayncTaskCallback)
      } else {
          taskFn(error)
      }
  });

  // 如果存在异步任务
  if (asyncTaskCount > 0) {
      // 超过 10s 后，强制退出
      setTimeout(() => {
          doExit();
      }, 10 * 1000)
  } else {
      doExit()
  }
};

至此，我们的进程退出监听工具就完成了，完整的实现可以查看这个开源库 async-exit-hook

https://github.com/darukjs/daruk-exit-hook

进程优雅退出

通常我们的 web server 在重启、被运行容器调度（pm2 或者 docker 等）、出现异常导致进程退出时，我们希望执行退出动作，如完成已经连接到服务的请求响应、清理数据库连接、打印错误日志、触发告警等，做完退出动作后，再退出进程，我们可以使用刚才的进程退出监听工具实现：

const http = require('http');

// 创建 web server
const server = http.createServer((req, res) => {
  res.writeHead(200);
  res.end('hello world\n');
}).listen(8000);

// 使用我们在上面开发的工具添加进程退出任务
addExitTask((error, callback) => {
   // 打印错误日志、触发告警、释放数据库连接等
   console.log('进程异常退出'， error)
   // 停止接受新的请求
   server.close((error) => {
       if (error) {
         console.log('停止接受新请求错误', error)
       } else {
         console.log('已停止接受新的请求')
       }
   })
   // 比较简单的做法是，等待一定的时间（这里我们等待 5s），让存量请求执行完毕
   // 如果要完全保证所有请求都处理完毕，需要记录每一个连接，在所有连接都释放后，才执行退出动作
   // 可以参考开源库 https://github.com/sebhildebrandt/http-graceful-shutdown
   setTimout(callback, 5 * 1000)
})

总结