Обещания не решаются так, как я ожидал

Question

Обещания не решаются так, как я ожидал

1

У меня есть следующее:

for (let job of jobs) {
  resets.push(
    new Promise((resolve, reject) => {
      let oldRef = job.ref
      this._sequenceService.attachRef(job).then(() => {
        this._dbService.saveDoc('job', job).then(jobRes => {
          console.log('[%s / %s]: %s', oldRef, jobRes['jobs'][0].ref, this._moment.unix(job.created).format('DD/MM/YYYY HH:mm'))
          resolve()
        }).catch(error => {
          reject(error)
        })
      }).catch(error => {
        reject(error)
      })
    })
  )
}

return Promise.all(resets).then(() => {
  console.log('Done')
})

this._sequenceService.attachRef имеет вызов console.log().

Когда это выполняется, я вижу все консольные журналы из this._sequenceService.attachRef() а затем я вижу все журналы в saveDoc.then(). Я ожидал увидеть их чередующимися. Я понимаю, что в соответствии с этой статьей обещания не разрешаются по порядку, но я не ожидал, что мое обещание разрешится до тех пор, пока я не назову resolve() поэтому все равно ожидаю чередующиеся журналы, даже если они не в порядке.

Почему это не так?

webnoob 18 янв. 2018, в 08:02

Источник

0

вы можете напрямую вернуть функцию then в массив, не заключая ее в обещание
zabusa 18 янв. 2018, в 07:02
0

Первоначально я сделал это, но изменил на это, так что я могу отлаживать, почему журналы консоли не в порядке, который я ожидаю. Я думал, что попытка resolve() вручную может помочь.
webnoob 18 янв. 2018, в 07:02
0

теперь его разрешение правильно?
zabusa 18 янв. 2018, в 07:04
1

Журналы не будут чередоваться. Promise.all запускает все обещания параллельно, и в каждом случае первый запрос this._sequenceService.attachRef выполняется для всех обещаний. Вероятно, все они заканчивают работу до того, как будет выполнен любой из вторых запросов ( this._dbService.saveDoc('job', job) )
Chirag Ravindra 18 янв. 2018, в 07:04
0

@ChiragRavindra - я понимаю, что Promise.all не Promise.all относиться к моему new Promise((resolve, reject)) как к обещанию разрешить и подождать, пока я Promise.all resolve() , чтобы определить, разрешено ли оно?
webnoob 18 янв. 2018, в 07:05
0

@zabusa - Нет, поэтому я перешел на этот стиль кодирования для отладки. У меня было это первоначально.
webnoob 18 янв. 2018, в 07:06
0

Да. Это должно быть поведение. Но запись в журнал происходит всякий раз, когда обработчик .then() запускается для каждого внутреннего обещания. Я ожидал, что console.log('Done') будет напечатан после всего. (т.е. все обещания, переданные Promise.all были выполнены
Chirag Ravindra 18 янв. 2018, в 07:07
0

@ChiragRavindra Да, это верно в отношении готового журнала, но я все еще не понимаю, почему вложенные обещания не входят в порядок. Конечно, он должен пройти каждый , then звонить, чтобы поразить свою resolve() и при этом призвал console.log . Для меня это должно означать, что журналы должны быть в порядке, потому что Promise.all будет игнорировать вложенное обещание, но будет ждать моего завернутого resolve()
webnoob 18 янв. 2018, в 07:14
0

все ваши обещания в параллельном порядке. Может быть, вы видите консоль других разрешенных обещаний в середине
zabusa 18 янв. 2018, в 07:16

Показать ещё 7 комментариев

Теги:

javascript

promise

2 ответа

2

Уточнение моих комментариев выше:

В этом случае обещания находятся на четырех уровнях.

Уровень 0: Обещание, созданное с помощью Promise.all

Уровень 1: Обещание, созданное с new Promise для каждого задания

Уровень 2: обещание, генерируемое this._sequenceService.attachRef(job)

Уровень 3: обещание, сгенерированное this._dbService.saveDoc('job', job)

Пусть говорят, что у нас есть два задания J1 и J2

Один возможный порядок исполнения:

L0 invoked

J1-L1 invoked
J2-L1 invoked

J1-L2 invoked
J2-L2 invoked

J1-L2 resolves, log seen at L2 for J1
J1-L3 invoked

J2-L2 resolves, log seen at L2 for J2
J2-L3 invoked

J1-L3 resolves, log seen at L3 for J1
J1-L1 resolves

J2-L3 resolves, log seen at L3 for J2
J2-L1 resolves

L0 resolves, 'Done' is logged

Вероятно, поэтому вы видите все журналы L2, затем все журналы L3, а затем, наконец, журнал Promise.all

Chirag Ravindra 18 янв. 2018, в 05:03

0

Хорошо, хорошо, теперь все ясно, спасибо. Я не думаю, что у вас есть способ заставить это работать так, как я ожидаю, а вы?
webnoob 18 янв. 2018, в 08:18
0

Я иногда использую Массив фабрик Promise (функции, которые возвращают обещания) в сочетании с вызовом Promise.all для массива, чтобы построить последовательную цепочку обещаний (вместо Promise.all ), когда порядок важен. Пример: promisefactoryArray.reduce((chain,pf)=>(chain.then(()=>pf())), Promise.reolve()) Однако подробное описание решения, которое я считаю, выходит за рамки способа, которым сформулирован этот вопрос. Вы могли бы также посмотрите на библиотеку async / wait, чтобы вызвать последовательное выполнение.
Chirag Ravindra 18 янв. 2018, в 08:21
0

Это хорошо, спасибо. Я согласен, что это выходит за рамки. Я, вероятно, просто буду ждать этого в этом случае, теперь я понимаю, что происходит под капотом немного лучше.
webnoob 18 янв. 2018, в 08:28
0

Извините, но я пометил другой ответ как правильный для этого, поскольку он более подробно рассказывает о том, что происходит и почему. Я ценю ваше время и усилия, помогающие мне понять, хотя.
webnoob 18 янв. 2018, в 09:19
0

Не волнуйтесь! Что бы ни отвечало на вопрос лучше всего :)
Chirag Ravindra 18 янв. 2018, в 09:22

Показать ещё 3 комментария

Ещё вопросы

вы можете напрямую вернуть функцию then в массив, не заключая ее в обещание
Первоначально я сделал это, но изменил на это, так что я могу отлаживать, почему журналы консоли не в порядке, который я ожидаю. Я думал, что попытка resolve() вручную может помочь.
теперь его разрешение правильно?
Журналы не будут чередоваться. Promise.all запускает все обещания параллельно, и в каждом случае первый запрос this._sequenceService.attachRef выполняется для всех обещаний. Вероятно, все они заканчивают работу до того, как будет выполнен любой из вторых запросов ( this._dbService.saveDoc('job', job) )
@ChiragRavindra - я понимаю, что Promise.all не Promise.all относиться к моему new Promise((resolve, reject)) как к обещанию разрешить и подождать, пока я Promise.all resolve() , чтобы определить, разрешено ли оно?
@zabusa - Нет, поэтому я перешел на этот стиль кодирования для отладки. У меня было это первоначально.
Да. Это должно быть поведение. Но запись в журнал происходит всякий раз, когда обработчик .then() запускается для каждого внутреннего обещания. Я ожидал, что console.log('Done') будет напечатан после всего. (т.е. все обещания, переданные Promise.all были выполнены
@ChiragRavindra Да, это верно в отношении готового журнала, но я все еще не понимаю, почему вложенные обещания не входят в порядок. Конечно, он должен пройти каждый , then звонить, чтобы поразить свою resolve() и при этом призвал console.log . Для меня это должно означать, что журналы должны быть в порядке, потому что Promise.all будет игнорировать вложенное обещание, но будет ждать моего завернутого resolve()
все ваши обещания в параллельном порядке. Может быть, вы видите консоль других разрешенных обещаний в середине
Хорошо, хорошо, теперь все ясно, спасибо. Я не думаю, что у вас есть способ заставить это работать так, как я ожидаю, а вы?
Я иногда использую Массив фабрик Promise (функции, которые возвращают обещания) в сочетании с вызовом Promise.all для массива, чтобы построить последовательную цепочку обещаний (вместо Promise.all ), когда порядок важен. Пример: promisefactoryArray.reduce((chain,pf)=>(chain.then(()=>pf())), Promise.reolve()) Однако подробное описание решения, которое я считаю, выходит за рамки способа, которым сформулирован этот вопрос. Вы могли бы также посмотрите на библиотеку async / wait, чтобы вызвать последовательное выполнение.
Это хорошо, спасибо. Я согласен, что это выходит за рамки. Я, вероятно, просто буду ждать этого в этом случае, теперь я понимаю, что происходит под капотом немного лучше.
Извините, но я пометил другой ответ как правильный для этого, поскольку он более подробно рассказывает о том, что происходит и почему. Я ценю ваше время и усилия, помогающие мне понять, хотя.
Не волнуйтесь! Что бы ни отвечало на вопрос лучше всего :)

jfriend00 · Accepted Answer · 2018-01-18T07-13-00.000Z

Ваш код может быть написан намного чище, избегая обещания анти-шаблона обернуть обещание в новом созданном вручную обещании. Вместо этого вы просто выдвигаете внешнее обещание в свой массив и связываете внутренние обещания с внешним, возвращая их из обработчика .then(). Все это можно сделать так просто:

for (let job of jobs) {
    let oldRef = job.ref;
    resets.push(this._sequenceService.attachRef(job).then(() => {
        // chain this promise to parent promise by returning it 
        // inside the .then() handler
        return this._dbService.saveDoc('job', job).then(jobRes => {
            console.log('[%s / %s]: %s', oldRef, jobRes['jobs'][0].ref, this._moment.unix(job.created).format('DD/MM/YYYY HH:mm'));
        });
    }));
}

return Promise.all(resets).then(() => {
    console.log('Done')
}).catch(err => {
    console.log(err);
});

Отклонения автоматически распространяются вверх, поэтому вам не нужны обработчики .catch() внутри цикла.

Что касается последовательности, вот что происходит:

Цикл for является синхронным. Он сразу же заканчивается.
Все вызовы .attachRef() являются асинхронными. Это означает, что вызов их только инициирует операцию, а затем они возвращаются, а остальная часть вашего кода продолжает работать. Это также называется неблокирующим.
Все обработчики .then() являются асинхронными. Самое раннее, что они могут запустить, - это следующий тик.
Таким образом, это объясняет, почему первое, что происходит, это все вызовы .attachRef() выполняемые с тех пор, как это делает цикл. Он сразу же вызывает все методы .attachRef(). Так как они только начинают свою работу, а затем сразу возвращаются, цикл for завершает работу, довольно быстро запуская все операции .attachRef().
Затем, когда заканчивается каждый .attachRef(), он вызывает .saveDoc() соответствующий .saveDoc().
Относительное время между тем, когда .saveDoc() вызовов .saveDoc() - это просто гонка, в зависимости от того, когда они начали (сколько времени .attachRef() их .attachRef()), и как долго их собственный .saveDoc() принял для выполнения. Это относительное время для всех этих событий, вероятно, не вполне предсказуемо, особенно если есть многопоточная база данных за кулисами, которая может обрабатывать несколько запросов одновременно.

Тот факт, что относительное время не предсказуемо, не должно быть неожиданностью. Вы выполняете несколько двухступенчатых асинхронных операций параллельно, что означает, что вам все равно, какой порядок они запускают или завершают. Они все участвуют друг в друге. Если бы все они выполняли ровно одно и то же время, чтобы выполнить без изменений, то они, вероятно, закончили бы в том же порядке, в котором они были запущены, но любые незначительные изменения времени выполнения могут, безусловно, изменить порядок завершения. Если базовая БД получает, то одновременно имеет место конфликт блокировки между всеми различными запросами в полете, что также может кардинально изменить время.

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

Блестящее объяснение, большое спасибо. Просто чтобы заметить, я использовал анти-шаблон только при отладке, так как я хотел убедиться, что это было не просто так, как я делал это раньше (как вы описали, это должно быть сделано). Я действительно хочу, чтобы все работало так, как есть (просто дайте мне знать, когда все будет сделано), но мне было любопытно, почему порядок не был таким, как я ожидал. Теперь я понимаю.