Node.js 信号处理机制：在异步环境中优雅处理 `SIGTERM` 的调度逻辑与资源清理模型

各位来宾，下午好！

今天，我们齐聚一堂，探讨一个在Node.js生产环境中至关重要，却又常常被忽视的主题：Node.js信号处理机制，特别是在异步环境中如何优雅地处理SIGTERM的调度逻辑与资源清理模型。作为一名编程专家，我深知构建健壮、高可用的系统，不仅仅是编写无bug的业务逻辑，更在于如何让系统在面临外部中断时，能够体面、安全地退出。

1. 优雅退出的必要性：生产环境的生命线

在分布式系统和微服务架构盛行的今天，应用程序的生命周期变得更加动态。容器编排工具如Kubernetes、Docker Swarm，以及进程管理器如PM2，会根据负载、部署更新或系统维护等需求，频繁地启动、停止、重启我们的服务实例。在这种背景下，一个应用程序如何响应终止信号，决定了其在整个生态系统中的“品格”。

想象一下，一个正在处理用户支付请求的Node.js服务，突然被强行终止（例如，通过kill -9或SIGKILL）。会发生什么？

• 数据不一致：支付事务可能只完成了一半，导致用户支付了钱，但订单未生成，或钱款扣除但未到账。
• 资源泄露：打开的文件句柄、数据库连接、网络套接字可能未被正确关闭，长期累积可能耗尽系统资源。
• 用户体验受损：正在进行的请求中断，用户收到错误提示，需要重新操作。
• 日志丢失：缓冲在内存中的日志可能来不及写入磁盘，导致问题排查困难。
• 服务中断：虽然新的实例可能迅速启动，但在旧实例强制退出期间，仍有短暂的服务不可用窗口。

因此，优雅退出（Graceful Shutdown）并非锦上添花，而是生产环境下的硬性要求，是保障数据完整性、系统稳定性与用户体验的生命线。它意味着当服务收到终止信号时，能够完成当前正在处理的任务，释放所有已占用的资源，然后安全退出。

2. Unix信号：软件中断的语言

在Unix-like系统中，信号（Signals）是一种进程间通信（IPC）的机制，用于通知进程发生了某种事件。它们本质上是异步的软件中断。当一个进程收到信号时，它会暂停当前执行，转而执行预设的信号处理函数（Signal Handler），或者执行默认操作。

2.1 常见信号及其含义

信号名称	编号	默认行为	常见用途
SIGHUP	1	终止进程	当终端关闭时发送给进程。常用于通知守护进程重新加载配置文件。
SIGINT	2	终止进程	中断信号，通常由用户按下 Ctrl+C 触发。
SIGQUIT	3	终止进程并生成核心转储	用户按下 Ctrl+ 触发。用于调试。
SIGTERM	15	终止进程	终止信号，程序化请求进程终止的标准方式。可被捕获和处理。
SIGKILL	9	立即终止进程（不可捕获，不可忽略，不可阻塞）	强制终止信号。用于杀死无响应的进程。

2.2 SIGTERM vs SIGKILL：请求与命令

在这些信号中，SIGTERM和SIGKILL是我们关注的焦点。

• SIGTERM（Terminate Signal，信号编号15）是请求进程终止的信号。它允许进程捕获并处理该信号，从而执行清理工作后优雅退出。这是进程管理器、容器编排系统（如Kubernetes默认发送的终止信号）请求应用停止的标准方式。
• SIGKILL（Kill Signal，信号编号9）是强制进程终止的信号。它不可被进程捕获、忽略或阻塞。一旦进程收到SIGKILL，操作系统会立即终止该进程，不给它任何机会进行清理。这通常是作为最后手段，当进程对SIGTERM无响应时才使用。

我们的目标，就是确保Node.js应用能够优雅地响应SIGTERM，避免被“SIGKILLed”。

3. Node.js信号处理基础

Node.js提供了一个非常直观的API来监听和处理操作系统信号：process.on('signalName', callback)。

当Node.js进程收到一个信号时，如果该信号没有被显式处理，Node.js会有默认行为。对于SIGTERM和SIGINT，Node.js的默认行为是终止进程。但一旦我们注册了监听器，默认行为就会被覆盖。

3.1 基本信号处理示例

// basic_signal_handler.js

console.log(`进程ID: ${process.pid}`);

// 监听 SIGTERM 信号
process.on('SIGTERM', () => {
    console.log('收到 SIGTERM 信号，准备退出...');
    // 在这里执行一些清理操作
    // ...
    process.exit(0); // 退出进程，0表示成功
});

// 监听 SIGINT 信号 (Ctrl+C)
process.on('SIGINT', () => {
    console.log('收到 SIGINT 信号 (Ctrl+C)，准备退出...');
    // 在这里执行一些清理操作
    // ...
    process.exit(0);
});

// 保持进程运行，否则它会立即退出
setInterval(() => {
    console.log('服务正在运行...');
}, 2000);

console.log('服务已启动，请发送 SIGTERM (kill -15 ' + process.pid + ') 或 SIGINT (Ctrl+C) 进行测试。');

运行此脚本：node basic_signal_handler.js
然后在一个新的终端中，使用kill -15 <pid>（替换<pid>为脚本输出的进程ID）或直接在运行脚本的终端按Ctrl+C。你会看到相应的日志输出，然后进程退出。

3.2 exit事件与信号事件的区别

process.on('exit', callback)事件在进程即将退出时触发，无论退出是由于显式调用process.exit()、未捕获的异常、还是信号终止。然而，exit事件是同步的。这意味着在exit事件的回调函数中，我们不能执行任何异步操作，例如网络请求、文件写入或数据库操作。它主要用于同步的资源清理，如刷新内存中的缓冲区。

相比之下，信号处理函数（如SIGTERM的处理器）是异步的，我们可以在其中执行任意的异步操作。这正是我们实现优雅退出的关键。

4. 异步环境的挑战：为何简单处理不够？

Node.js以其非阻塞I/O和事件驱动的特性而闻名，这使得它天生适合处理高并发的异步操作。但这种异步性也给优雅退出带来了复杂性。

考虑以下场景：

1. 一个HTTP服务器正在处理数十个并发请求，其中一些请求涉及到耗时的数据库查询或外部API调用。
2. 一个消息队列消费者刚从队列中取出一条消息，正在进行复杂的业务逻辑处理。
3. 一个定时任务刚刚启动，正在执行批量数据处理。

如果此时SIGTERM信号到来，而我们的信号处理函数只是简单地调用process.exit(0)，那么：

• 正在进行的HTTP请求会被突然中断：客户端收到连接重置或超时错误。
• 消息队列中的消息可能“丢失”或重复处理：如果消息未确认（ACK），它可能被重新投递给其他消费者；如果已确认但业务处理未完成，数据可能不一致。
• 定时任务可能半途而废：导致数据处理不完整。

问题核心在于：process.exit()会立即终止所有正在进行的JavaScript执行，包括异步回调。 即使有未完成的Promise或async/await操作，它们也会被无情地切断。

因此，我们需要一种策略，能够：

1. 停止接收新任务：确保不再有新的请求或消息进入系统。
2. 完成现有任务：给予足够的时间让所有正在进行的异步操作自然结束。
3. 释放所有资源：关闭数据库连接、文件句柄、网络套接字等。
4. 安全退出：在所有清理工作完成后，才调用process.exit()。

5. 优雅退出策略：多阶段调度模型

为了应对异步环境的挑战，我们需要采纳一个多阶段的、有条不紊的调度模型。这就像一艘巨轮靠港：首先停止推进器，然后慢慢滑行，最后抛锚，而不是直接撞向码头。

5.1 阶段划分

我们可以将优雅退出过程划分为以下核心阶段：

阶段	目标	典型操作示例
1. 停止接收新任务 (Draining)	阻止新的工作负载进入系统。	HTTP服务器停止监听新连接；消息队列消费者停止从队列拉取消息；定时器停止注册新任务。
2. 完成现有任务 (Flushing)	等待所有已接受的、正在处理中的任务完成。	等待所有HTTP请求响应完毕；等待所有数据库事务提交/回滚；等待所有消息处理完成。
3. 释放资源 (Cleaning Up)	关闭所有持久化连接和文件句柄。	关闭数据库连接池；关闭消息队列连接；关闭文件系统观察者；清空缓存。
4. 安全退出 (Exiting)	在所有清理工作完成后，通知操作系统进程可以安全终止。	调用 process.exit(0)。

5.2 调度逻辑：时间与优先级的考量

整个退出过程必须在一定时间内完成，否则外部的进程管理器可能会发送SIGKILL。因此，引入一个优雅退出超时时间 (Grace Period Timeout) 是至关重要的。

调度逻辑可以概括为：

1. 捕获信号：当SIGTERM或SIGINT到来时，启动优雅退出流程。
2. 设置超时：启动一个定时器，如果在预设的超时时间内未能完成所有清理，则强制退出。
3. 执行清理任务：按照阶段顺序执行预定义的清理函数。这些函数通常是异步的。
4. 并发与串行：同一阶段内的清理任务可以并行执行（如关闭多个数据库连接），不同阶段之间通常是串行的。
5. 完成退出：所有清理任务完成后，清除超时定时器，并调用process.exit(0)。
6. 强制退出：如果超时，或者在优雅退出过程中收到第二次终止信号，则直接调用process.exit(1)（表示非正常退出）或 process.exit(0)（取决于策略）。

6. Node.js中实现优雅退出：代码实践

现在，让我们通过具体的代码示例来展示如何在Node.js中实现这一多阶段调度模型。

6.1 HTTP服务器的优雅关闭

Node.js的http.Server实例有一个close()方法，它非常适合实现第一阶段和第二阶段的一部分：

• server.close([callback])：停止服务器接受新的连接，并等待所有现有连接断开。当所有连接都断开后，回调函数会被调用。
• 注意：server.close()不会强制断开现有连接。如果客户端一直不关闭连接（例如，长轮询或WebSocket），服务器将一直等待。为了解决这个问题，我们需要设置一个timeout，或者手动追踪并销毁空闲连接。

// http_server_shutdown.js
const http = require('http');

let connections = new Set(); // 用于追踪所有活动连接

const server = http.createServer((req, res) => {
    console.log(`收到请求: ${req.url}`);
    // 模拟一个异步耗时操作
    setTimeout(() => {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Hello from Node.js server!n');
    }, Math.random() * 1000 + 500); // 0.5s - 1.5s 随机延迟
});

server.on('connection', (socket) => {
    connections.add(socket);
    socket.on('close', () => {
        connections.delete(socket);
    });
});

const PORT = 3000;
server.listen(PORT, () => {
    console.log(`HTTP Server 运行在 http://localhost:${PORT}`);
    console.log(`进程ID: ${process.pid}`);
});

// ==========================================================
// 优雅退出逻辑
// ==========================================================

let isShuttingDown = false;
const GRACE_PERIOD_MS = 10000; // 10秒的优雅退出时间

async function gracefulShutdown() {
    if (isShuttingDown) {
        console.warn('已在关闭过程中，忽略重复的关闭请求。');
        return;
    }
    isShuttingDown = true;
    console.log('----------------------------------------------------');
    console.log('收到终止信号，开始优雅退出...');

    // 启动一个超时计时器
    const shutdownTimeout = setTimeout(() => {
        console.error(`优雅退出超时 (${GRACE_PERIOD_MS / 1000}秒)，强制退出！`);
        // 销毁所有剩余连接，避免进程挂起
        connections.forEach(socket => socket.destroy());
        process.exit(1); // 非正常退出
    }, GRACE_PERIOD_MS);

    try {
        // 阶段 1: 停止接收新任务 (HTTP Server)
        console.log('1. 停止HTTP服务器接收新连接...');
        await new Promise((resolve, reject) => {
            server.close(err => {
                if (err) {
                    console.error('HTTP服务器关闭错误:', err.message);
                    return reject(err);
                }
                console.log('HTTP服务器已停止接受新连接。');
                resolve();
            });
        });

        // 阶段 2: 完成现有任务 (HTTP Server)
        // server.close() 会等待现有连接断开，但不会强制断开。
        // 我们需要等待 connections Set 为空。
        console.log(`2. 等待 ${connections.size} 个活动连接完成...`);
        let intervalId;
        await new Promise(resolve => {
            if (connections.size === 0) {
                return resolve();
            }
            intervalId = setInterval(() => {
                console.log(`当前活动连接数: ${connections.size}`);
                if (connections.size === 0) {
                    clearInterval(intervalId);
                    resolve();
                }
            }, 500); // 每0.5秒检查一次
        });
        if (intervalId) clearInterval(intervalId); // 确保清除
        console.log('所有HTTP连接均已完成。');

        // 阶段 3: 释放其他资源（模拟数据库连接、消息队列等）
        console.log('3. 释放其他资源...');
        await Promise.all([
            // 模拟数据库连接关闭
            new Promise(res => {
                console.log('关闭数据库连接...');
                setTimeout(() => {
                    console.log('数据库连接已关闭。');
                    res();
                }, 1000); // 模拟1秒关闭时间
            }),
            // 模拟消息队列消费者停止和连接关闭
            new Promise(res => {
                console.log('停止消息队列消费者并关闭连接...');
                setTimeout(() => {
                    console.log('消息队列连接已关闭。');
                    res();
                }, 800); // 模拟0.8秒关闭时间
            }),
            // 模拟刷新日志
            new Promise(res => {
                console.log('刷新日志...');
                setTimeout(() => {
                    console.log('日志已刷新。');
                    res();
                }, 300); // 模拟0.3秒刷新时间
            })
        ]);
        console.log('所有其他资源已释放。');

        // 阶段 4: 安全退出
        console.log('所有清理工作完成，安全退出！');
        clearTimeout(shutdownTimeout); // 清除超时定时器
        process.exit(0);

    } catch (error) {
        console.error('优雅退出过程中发生错误:', error);
        clearTimeout(shutdownTimeout);
        process.exit(1); // 错误退出
    }
}

// 监听 SIGTERM 和 SIGINT 信号
process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

// 监听未捕获的异常，确保也能触发优雅退出
process.on('uncaughtException', (err) => {
    console.error('未捕获的异常:', err);
    gracefulShutdown(); // 尝试优雅退出
});

process.on('unhandledRejection', (reason, promise) => {
    console.error('未处理的Promise拒绝:', reason);
    gracefulShutdown(); // 尝试优雅退出
});

测试方法：

1. 运行 node http_server_shutdown.js。
2. 在浏览器中访问 http://localhost:3000 几次，模拟正在进行的请求。
3. 在另一个终端中，执行 kill -15 <pid>（替换<pid>为脚本输出的进程ID）。
4. 观察控制台输出，你会看到服务器停止接受新连接，并等待现有请求完成，然后关闭数据库、消息队列等，最后安全退出。
5. 如果等待时间过长，会触发超时强制退出。

6.2 模块化和可配置的优雅退出管理器

将优雅退出逻辑封装成一个可重用的模块，可以提高代码的可维护性和复用性。

// gracefulShutdownManager.js

class GracefulShutdownManager {
    constructor(options = {}) {
        this.gracePeriodMs = options.gracePeriodMs || 15000; // 默认15秒
        this.shutdownTasks = [];
        this.isShuttingDown = false;
        this.shutdownTimeoutId = null;
        this.signalCount = 0; // 用于处理多次信号，例如强制退出
        console.log(`[ShutdownManager] 初始化，优雅退出宽限期: ${this.gracePeriodMs / 1000}秒`);
    }

    /**
     * 注册一个异步清理任务
     * @param {string} name 任务名称
     * @param {Function} taskFn 异步函数，应返回Promise或使用async/await
     */
    registerTask(name, taskFn) {
        if (typeof taskFn !== 'function') {
            throw new Error('Shutdown task must be a function.');
        }
        this.shutdownTasks.push({ name, taskFn });
        console.log(`[ShutdownManager] 注册任务: "${name}"`);
    }

    /**
     * 启动优雅退出流程
     * @param {string} signal 触发关闭的信号名称 (可选)
     */
    async initiateShutdown(signal = 'UNKNOWN') {
        this.signalCount++;
        if (this.isShuttingDown) {
            console.warn(`[ShutdownManager] 已在关闭过程中 (信号: ${signal})，当前信号计数: ${this.signalCount}`);
            if (this.signalCount >= 2) {
                console.error('[ShutdownManager] 收到多次终止信号，强制立即退出！');
                clearTimeout(this.shutdownTimeoutId);
                process.exit(1); // 强制退出
            }
            return;
        }

        this.isShuttingDown = true;
        console.log(`n[ShutdownManager] 收到信号 "${signal}"，开始优雅退出...`);

        // 启动超时计时器
        this.shutdownTimeoutId = setTimeout(() => {
            console.error(`[ShutdownManager] 优雅退出超时 (${this.gracePeriodMs / 1000}秒)，强制退出！`);
            process.exit(1);
        }, this.gracePeriodMs);

        try {
            for (const task of this.shutdownTasks) {
                console.log(`[ShutdownManager] 执行任务: "${task.name}"...`);
                await task.taskFn();
                console.log(`[ShutdownManager] 任务 "${task.name}" 完成。`);
            }

            console.log('[ShutdownManager] 所有清理任务完成，安全退出！');
            clearTimeout(this.shutdownTimeoutId);
            process.exit(0);

        } catch (error) {
            console.error('[ShutdownManager] 优雅退出过程中发生错误:', error);
            clearTimeout(this.shutdownTimeoutId);
            process.exit(1); // 错误退出
        }
    }

    /**
     * 注册信号处理器和未捕获异常处理器
     */
    registerProcessListeners() {
        process.on('SIGTERM', () => this.initiateShutdown('SIGTERM'));
        process.on('SIGINT', () => this.initiateShutdown('SIGINT'));

        process.on('uncaughtException', (err) => {
            console.error('[ShutdownManager] 未捕获的异常:', err);
            this.initiateShutdown('UNCAUGHT_EXCEPTION');
        });

        process.on('unhandledRejection', (reason, promise) => {
            console.error('[ShutdownManager] 未处理的Promise拒绝:', reason);
            this.initiateShutdown('UNHANDLED_REJECTION');
        });

        // 可选：监听 exit 事件，但记得其中不能有异步操作
        process.on('exit', (code) => {
            console.log(`[ShutdownManager] 进程即将退出，退出码: ${code}`);
            // 可以在这里执行一些同步的资源清理，如清空缓冲区
        });
    }
}

module.exports = GracefulShutdownManager;

使用 GracefulShutdownManager 的示例：

// app.js (使用 GracefulShutdownManager)
const http = require('http');
const GracefulShutdownManager = require('./gracefulShutdownManager');

// 模拟外部资源
let dbConnection = null;
let messageQueueClient = null;
let activeHttpConnections = new Set(); // 用于HTTP服务器

async function connectToDatabase() {
    return new Promise(resolve => {
        console.log('[App] 正在连接数据库...');
        setTimeout(() => {
            dbConnection = {
                query: (sql) => console.log(`[DB] Executing: ${sql}`),
                close: () => new Promise(res => {
                    console.log('[DB] 正在关闭数据库连接...');
                    setTimeout(() => { console.log('[DB] 数据库连接已关闭。'); res(); }, 1000);
                })
            };
            console.log('[App] 数据库连接成功。');
            resolve();
        }, 1500);
    });
}

async function connectToMessageQueue() {
    return new Promise(resolve => {
        console.log('[App] 正在连接消息队列...');
        setTimeout(() => {
            messageQueueClient = {
                stopConsumer: () => new Promise(res => {
                    console.log('[MQ] 正在停止消费者...');
                    setTimeout(() => { console.log('[MQ] 消费者已停止。'); res(); }, 800);
                }),
                disconnect: () => new Promise(res => {
                    console.log('[MQ] 正在断开连接...');
                    setTimeout(() => { console.log('[MQ] 连接已断开。'); res(); }, 500);
                })
            };
            console.log('[App] 消息队列连接成功。');
            resolve();
        }, 1200);
    });
}

async function main() {
    await connectToDatabase();
    await connectToMessageQueue();

    const shutdownManager = new GracefulShutdownManager({ gracePeriodMs: 10000 }); // 10秒宽限期
    shutdownManager.registerProcessListeners();

    // 1. 注册HTTP服务器关闭任务
    const server = http.createServer((req, res) => {
        console.log(`[HTTP] 收到请求: ${req.url}`);
        dbConnection.query('SELECT * FROM users'); // 模拟数据库操作
        setTimeout(() => {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end('Hello from Node.js server!n');
        }, Math.random() * 800 + 400); // 0.4s - 1.2s 随机延迟
    });

    server.on('connection', (socket) => {
        activeHttpConnections.add(socket);
        socket.on('close', () => activeHttpConnections.delete(socket));
    });

    const HTTP_PORT = 3001;
    server.listen(HTTP_PORT, () => {
        console.log(`[App] HTTP Server 运行在 http://localhost:${HTTP_PORT}`);
        console.log(`[App] 进程ID: ${process.pid}`);
    });

    shutdownManager.registerTask('HTTP Server Shutdown', async () => {
        console.log('[ShutdownTask] 停止HTTP服务器接收新连接...');
        await new Promise((resolve, reject) => {
            server.close(err => {
                if (err) {
                    console.error('[ShutdownTask] HTTP服务器关闭错误:', err.message);
                    return reject(err);
                }
                console.log('[ShutdownTask] HTTP服务器已停止接受新连接。');
                resolve();
            });
        });

        console.log(`[ShutdownTask] 等待 ${activeHttpConnections.size} 个活动HTTP连接完成...`);
        let intervalId;
        await new Promise(resolve => {
            if (activeHttpConnections.size === 0) {
                return resolve();
            }
            intervalId = setInterval(() => {
                console.log(`[ShutdownTask] 当前活动HTTP连接数: ${activeHttpConnections.size}`);
                if (activeHttpConnections.size === 0) {
                    clearInterval(intervalId);
                    resolve();
                }
            }, 500);
        });
        if (intervalId) clearInterval(intervalId);
        console.log('[ShutdownTask] 所有HTTP连接均已完成。');
    });

    // 2. 注册数据库连接关闭任务
    shutdownManager.registerTask('Database Disconnect', async () => {
        if (dbConnection) {
            await dbConnection.close();
        }
    });

    // 3. 注册消息队列客户端关闭任务
    shutdownManager.registerTask('Message Queue Disconnect', async () => {
        if (messageQueueClient) {
            await messageQueueClient.stopConsumer();
            await messageQueueClient.disconnect();
        }
    });

    // 4. 注册其他清理任务，例如刷新日志
    shutdownManager.registerTask('Flush Logs', async () => {
        console.log('[ShutdownTask] 刷新日志...');
        await new Promise(res => setTimeout(() => {
            console.log('[ShutdownTask] 日志已刷新。');
            res();
        }, 500));
    });

    console.log('[App] 服务已完全启动。');
}

main().catch(err => {
    console.error('[App] 主应用启动失败:', err);
    process.exit(1);
});

测试方法：

1. 运行 node app.js。
2. 在浏览器中访问 http://localhost:3001 几次，模拟正在进行的请求。
3. 在另一个终端中，执行 kill -15 <pid>。
4. 观察输出，可以看到清晰的任务执行顺序和状态。
5. 可以尝试在优雅退出过程中再次发送SIGTERM，观察强制退出逻辑。

7. 高级考量与最佳实践

7.1 Idempotency (幂等性) of Cleanup Tasks

确保你的清理任务是幂等的。这意味着即使任务被调用多次，其结果也应该与调用一次相同，并且不会引发错误。例如，多次调用dbConnection.close()不应该导致问题。

7.2 日志记录的策略

在优雅退出过程中，详细的日志记录至关重要。它能帮助我们理解退出流程中的瓶颈或失败点。

• 使用异步日志库（如Winston, Pino）时，确保在关闭前刷新其缓冲区。
• 将日志级别调整为debug或info，以捕获更多详细信息。

7.3 与部署环境的协同

优雅退出并非孤立进行，它与你的部署环境紧密互动。

7.3.1 Load Balancers (负载均衡器) 与 Health Checks (健康检查)

在开始优雅退出之前，理想情况下，应用程序应该首先通知负载均衡器它不再准备接收新流量。这通常通过健康检查失败或在Kubernetes中使用preStop hook来完成。

• Kubernetes preStop Hook: 这是一个在Pod被终止信号发送之前执行的命令或HTTP请求。你可以在这里执行一个轻量级的操作，通知你的服务注册中心或负载均衡器将该实例从可用列表中移除。

  apiVersion: v1
  kind: Pod
  metadata:
    name: my-node-app
  spec:
    containers:
    - name: app-container
      image: my-node-app:latest
      lifecycle:
        preStop:
          exec:
            command: ["/bin/sh", "-c", "sleep 5 && kill -SIGTERM 1"] # 等待5秒，让负载均衡器有时间移除，然后发送SIGTERM给主进程

  注意: kill -SIGTERM 1 是因为在容器中PID 1是你的Node.js应用，除非你使用了dumb-init等工具。Kubernetes会在preStop完成后才发送SIGTERM给容器主进程。

7.3.2 Docker

Docker默认在容器停止时发送SIGTERM。你可以通过STOPSIGNAL指令在Dockerfile中自定义停止信号。

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]
STOPSIGNAL SIGTERM # 明确指定停止信号，尽管这是默认值

使用docker stop命令会发送SIGTERM，并等待10秒（默认--time参数）后发送SIGKILL。

7.3.3 Kubernetes

Kubernetes的Pod终止流程是：

1. 用户或控制器删除Pod。
2. Pod进入Terminating状态。
3. 如果配置了preStop hook，则执行。
4. 同时，Endpoint Controller将Pod从Service的Endpoints列表中移除，使其不再接收新流量。
5. terminationGracePeriodSeconds（默认为30秒）开始计时。
6. 向Pod中的容器主进程发送SIGTERM。
7. 如果terminationGracePeriodSeconds到期，Pod仍未退出，则发送SIGKILL。

7.3.4 PM2

PM2是一个流行的Node.js进程管理器。它也支持优雅退出：

// ecosystem.config.js
module.exports = {
  apps : [{
    name: "my-node-app",
    script: "./app.js",
    instances: "max",
    exec_mode: "cluster",
    // 优雅退出配置
    wait_ready: true, // 如果应用能发出 'ready' 事件，PM2会等待
    listen_timeout: 3000, // PM2等待'ready'事件的超时时间
    kill_timeout: 5000, // PM2发送SIGTERM后等待的毫秒数，超过后发送SIGKILL
    restart_delay: 1000, // 进程重启前的延迟
    // stop_exit_codes: [0], // 哪些退出码被认为是正常停止
  }]
};

这里的kill_timeout就是Node.js应用处理SIGTERM的gracePeriodMs。

7.4 区分SIGINT和SIGTERM的策略

虽然通常我们将SIGINT和SIGTERM映射到相同的优雅退出逻辑，但在某些高级场景中，可能需要区别对待。例如：

• SIGINT（用户手动Ctrl+C）可能希望更快地退出，即使这意味着中断一些非关键任务。
• SIGTERM（系统或编排器发送）则严格遵循优雅退出流程。
  在我们的GracefulShutdownManager中，通过signalCount的逻辑已经可以处理多次信号的情况，这是一种更通用的方式。

7.5 unref() 方法

对于某些计时器（setTimeout, setInterval）或网络套接字，如果它们是唯一阻止Node.js进程退出的事件，你可以使用.unref()方法。调用unref()后，该计时器或套接字将不再阻止进程退出。这在后台任务或监控工具中很有用，它们不应该影响主应用的生命周期。

const timer = setTimeout(() => {
    console.log('这个定时器不会阻止进程退出');
}, 5000);
timer.unref();

const server = net.createServer((socket) => {
    // ...
});
server.unref(); // 这个服务器不再阻止进程退出

但这应该谨慎使用，因为如果unref()的资源是核心业务逻辑的一部分，那么进程可能会在它完成之前就退出。通常，在优雅退出流程中，我们更倾向于显式地关闭所有重要资源。

8. 总结：深思熟虑的终止，铸就韧性服务

优雅退出不仅仅是一个技术细节，它更是构建弹性、可靠的Node.js应用程序的核心组成部分。在异步的Node.js环境中，简单地监听SIGTERM并调用process.exit()是远远不够的。我们需要一个深思熟虑、多阶段的调度模型，以确保在服务停止时：

1. 不再接受新的工作负载。
2. 所有正在进行的任务都能被妥善完成。
3. 所有已占用的资源都能被安全释放。
4. 在预设的宽限期内完成上述所有操作，否则进行强制终止。

通过将这些逻辑封装成可复用的模块，并与部署环境（如Docker、Kubernetes、PM2）的生命周期管理机制紧密结合，我们可以大大提高应用的健壮性，减少潜在的数据丢失和系统中断，从而为用户提供更加稳定和可靠的服务体验。一个能够优雅退出的服务，才是真正成熟、有韧性的服务。