承诺：当当前函数完成时，nodejs是否有堆栈将下一个放在谁后面？

Question

我有这个简单的代码：

(async () => {
    console.log("start");
    let flag = true;
    let promise = new Promise((res) => {
        while(flag) {}
        console.log("finish promise");
        res(true);
    });
    flag = false;
    await Promise.all(promise);
    console.log("finish process");
})();

因此，我希望输出如下：

start
finish promise
finish process

但是我只有start。这是因为while(flag)阻止了整个过程。

但是，如果Promise确实是异步的，那么该过程应该继续进行，并且标记将其关闭，等待Promise，然后打印其余的输出吗？

在另一个示例中，在这种情况下，我可以期望得到相同的输出：

function one() {
    return new Promise((res) => {
        for (let i = 0; i < 100000; ++i) {} // Imagine huge process...
        console.log("one");
        res(true);
    });
}
function two() {
    return new Promise((res) => {
        for (let i = 0; i < 10; ++i) {}
        console.log("two");
        res(true);
    });
}
(async () => {
    await Promise.all([one(), two(), one(), two()]);
    console.log("finish process");
})();

所以，我总是希望得到类似以下的输出：

one
two
one
two
finish process

在promise场景中，不可能获得另一种输出吗？这是否意味着诺言不会并行或同时运行您的流程？

因此出于实验原因，如果我更改这样的功能：

function one() {
    return new Promise((res) => {
        setTimeout(() => {
            for (let i = 0; i < 1000000000; ++i) {} // Imagine huge process...
            console.log("one");
            res(true);
        }, 500);
    });
}
function two() {
    return new Promise((res) => {
        setTimeout(() => {
            console.log("two");
            res(true);
        }, 1000);
    });
}
(async () => {
    await Promise.all([two(), two(), one(), one()]);
    console.log("finish process");
})();

我总是得到相同的输出：

one
one
two
two
finish process

那么我们能不能问一下nodejs是否有一个堆栈，当当前函数完成时，谁将下一个放在谁后面？