Async函数finally块中await未等待，Node.js进程提前退出问题排查

问题背景 #

我写了一段用于学习的Node.js测试代码：

const run = new Promise((resolve, reject) => {
    (async () => {
        let cleanup = () => {
            console.log('inside cleanup');
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve();
                }, 5000);
            });
        };

        try {
            throw new Error('error');
        } catch (err) {
            console.log('rejecting')
            reject(err);
        } finally {
            console.log('inside finally')
            await cleanup().then(() => {
                console.log('exiting');
                resolve('done');
            });
        }
    })();
});

run.then((r) => console.log(r));

原本预期Node.js会等待finally块内的Promise完成后再退出，但实际执行时进程立即退出，输出如下：

$ node pup
rejecting
inside finally
inside cleanup
D:\pup.js:16
            throw new Error('error');
                  ^

我的疑问：我忽略了什么要点？另外，我需要按特定顺序清理多个资源，必须等待前一项清理完成后再进行下一项。

核心问题解析 #

1. 独立异步函数的异常未被捕获 #

你在Promise构造器内部启动了一个自执行异步函数，但这个函数的异常没有被任何逻辑捕获。当catch块调用reject(err)后，外部的run Promise已经进入rejected状态，此时finally块里的resolve('done')不会改变这个状态；更关键的是，这个异步函数后续的await逻辑属于独立的Promise链，一旦出现未处理的异常（或者Node.js认为没有待处理的异步任务），就会直接触发进程退出。

2. Promise构造器的执行逻辑误区 #

Promise构造器的执行器（executor）是同步执行的，你在里面启动的自执行异步函数脱离了run这个Promise的控制链。当你调用reject(err)后，Node.js会检查事件循环：此时没有被外部代码显式等待的pending异步任务，所以直接退出进程，不会等待finally块里的await操作完成。

3. Promise状态无法重复修改 #

Promise的状态一旦变更为resolved或rejected就无法再修改。catch块已经调用reject(err)将run置为rejected状态，后续finally块里的resolve('done')完全无效。

解决方案 #

修正核心逻辑：让异步流程归属于Promise链 #

不要在Promise构造器里嵌套独立的异步函数，直接将整个逻辑包装为async函数并返回Promise，这样所有异步操作都会被纳入统一的Promise控制链：

const run = (async () => {
    let cleanup = () => {
        console.log('inside cleanup');
        return new Promise((resolve) => {
            setTimeout(() => {
                resolve();
            }, 5000);
        });
    };

    try {
        throw new Error('error');
    } catch (err) {
        console.log('rejecting');
        // 保留错误抛出，让外部catch处理
        throw err;
    } finally {
        console.log('inside finally');
        await cleanup();
        console.log('exiting');
    }
    return 'done';
})();

run.then((r) => console.log(r)).catch((err) => console.error(err));

按顺序清理多个资源的实现 #

如果需要按顺序清理资源，直接在finally块里按顺序await每个清理函数即可——await会自动等待前一个Promise完成后，再执行下一个清理操作：

// 模拟不同资源的清理函数
const cleanupDB = () => {
    console.log('cleaning up database connection');
    return new Promise(resolve => setTimeout(resolve, 2000));
};

const cleanupCache = () => {
    console.log('cleaning up cache client');
    return new Promise(resolve => setTimeout(resolve, 3000));
};

const run = (async () => {
    try {
        throw new Error('business logic error');
    } catch (err) {
        console.log('rejecting');
        throw err;
    } finally {
        console.log('starting cleanup sequence');
        // 严格按顺序清理：先数据库，再缓存
        await cleanupDB();
        await cleanupCache();
        console.log('all resources cleaned up');
    }
})();

run.catch(err => console.error(err.stack));

关键总结 #

• 避免在Promise构造器内嵌套独立的异步函数，直接用async函数返回Promise来管理整个异步流程。
• Promise状态不可修改，不要在finally块尝试覆盖之前的resolved/rejected状态。
• 所有需要等待的异步操作必须被纳入Promise链，确保Node.js能检测到pending任务，不会提前退出。
• 顺序清理资源只需按顺序await每个异步清理函数，天然保证执行顺序。

内容的提问来源于stack exchange，提问作者Max Koretskyi