Почему мое цепочечное обещание блокируется?

Question

У меня есть метод класса, который связывает воедино другие методы в классе, а также вызывает метод для другого экземпляра класса:

class Thing {
    doSomething(nextThing) {
        return new Promise((resolve) =>
            this.initialize()
                .then(() => this.doA())
                .then(() => {
                    nextThing.initialize(); // call initialize() on another instance
                    return this.doB();
                })
                .then(() => this.doC())
                .then(resolve)
        );
    }

    initialize() {
        return new Promise((resolve) => {
            // take a long time to do something
            // ...
            // ...
            resolve();
        });
    }

    doA() { return new Promise((resolve) => resolve()); }

    doB() { return new Promise((resolve) => resolve()); }

    doC() { return new Promise((resolve) => resolve()); }
}

const thing1 = new Thing();
const thing2 = new Thing();

thing1.doSomething(thing2);

Вызов функции на другом экземпляре класса блокирует потокцепи, однако;this.doB() и nextThing.initialize() будут работать одновременно (по желанию), но this.doC() не будет работать до тех пор, пока не разрешится nextThing.initialize().

Какой правильный способ убедиться, что это происходит так, как ожидалось, с помощью nextThing.initialize() и this.doB() запускаются одновременно и запускаются this.doC() сразу после разрешения this.doB()?Это нормально, если nextThing.initialize() разрешится после this.doC().

Answer 1

Когда вы делаете эту структуру:

return new Promise(resolve => {
    // run some long synchronous piece of code
    resolve(...);
});

Вот что происходит.

1. Создается новый объект обещания
2. Обратный вызов исполнителя обещания вызывается синхроннокак часть выполнения конструктора обещаний
3. Ваш долго выполняющийся синхронный код называется omback callback исполнителя
4. Вы вызываете resolve(...) для разрешения ранее созданного обещания
5. Вы возвращаетеот исполнителя обещаний
6. Конструктор обещаний возвращает
7. Вы вернетесь из функции хоста и строка кода после этого вызова функции будет запущена
8. Некоторое время спустя (после того, кактекущая часть Javascript возвращает управление обратно в систему), обработчики .then() вызываются в предыдущем обещании.

Итак, обещание синхронно вызывает обратный вызов исполнителя.Это не позволяет вам «запускать что-либо в фоновом режиме».Javascript все еще однопоточный.

Невозможно использовать обещание, чтобы превратить синхронный код в асинхронный код.Вы можете использовать некоторые методы обещаний, чтобы изменить расписание выполнения кода, но синхронный код в Javascript по-прежнему является синхронным и блокирует код в Javascript независимо от того, когда он выполняется.

Обещания - это просто система уведомлений для уведомления вас, когдакакая-то другая операция дала обещание, что теперь она решена или отклонена.Они магическим образом не преобразуют синхронный код в асинхронный код.

Итак, суть в том, что вы не можете использовать обещания взять синхронную долгосрочную функцию initialize() и каким-то образом сделать ее неблокирующей или асинхронной.

Какой правильный способ убедиться, что все идет так, как ожидалось, с одновременным запуском nextThing.initialize () и this.doB (),

Если nextThing.initialize()синхронный и блокирующий, он не может работать одновременно ни с чем.node.js запускает ваш Javascript однопоточным.Одна часть Javascript работает одновременно.Обещания не могут это изменить.

и запуск this.doC () сразу после того, как разрешается this.doB ()

, поскольку this.doB() и this.doC() оба возвращаютОбещания, затем вы объединяете обещания в цепочку обработчиков .then() для последовательности этих операций.Ваш код, кажется, уже делает это.

Для получения информации об опциях для выгрузки долго выполняющегося синхронного кода вне текущего потока Javascript для node.js, см. Этот другой ответ:

Сделайте функцию, требующую больших затрат времени, асинхронной

---

К вашему сведению, возможно, это просто псевдокод, но нет никаких причин для этого:

return new Promise((resolve) => resolve());

Вместо этого вы можете просто сделать:

return Promise.resolve();.