Czy Node.js natywny Promise.all przetwarza równolegle czy sekwencyjnie?

Chciałbym to wyjaśnić, ponieważ dokumentacja nie jest na ten temat zbyt jasna;

P1: Czy Promise.all(iterable)wszystkie obietnice są przetwarzane sekwencyjnie czy równolegle? A dokładniej, jest to odpowiednik wykonywania obietnic łańcuchowych, takich jak

p1.then(p2).then(p3).then(p4).then(p5)....

czy jest jakiś inny rodzaj algorytmu, gdzie wszystko p1, p2, p3, p4, p5, itd. są nazywane jednocześnie (równolegle) i wyniki są zwracane najszybciej jak wszystkim determinacji (lub jeden odrzutów)?

P2: Jeśli Promise.alldziała równolegle, czy istnieje wygodny sposób na sekwencyjne uruchamianie iterowalnych?

Uwaga : nie chcę używać Q ani Bluebird, ale wszystkie natywne specyfikacje ES6.

Czy Promise.all(iterable)dotrzymujesz wszystkich obietnic?

Nie, obietnic nie można „zrealizować”. Rozpoczynają swoje zadanie, gdy są tworzone - przedstawiają tylko wyniki - a Ty wykonujesz wszystko równolegle, nawet przed przekazaniem ich do Promise.all.

Promise.allczeka tylko na wiele obietnic. Nie ma znaczenia, w jakiej kolejności rozwiązują, ani czy obliczenia są wykonywane równolegle.

czy istnieje wygodny sposób na sekwencyjne uruchamianie iterowalnego?

Jeśli masz już swoje obietnice, nie możesz wiele zrobić, ale Promise.all([p1, p2, p3, …])(co nie ma pojęcia kolejności). Ale jeśli masz iterowalne funkcje asynchroniczne, możesz rzeczywiście uruchamiać je sekwencyjnie. Zasadniczo musisz wyjść z

[fn1, fn2, fn3, …]

do

fn1().then(fn2).then(fn3).then(…)

a rozwiązaniem jest użycie Array::reduce:

iterable.reduce((p, fn) => p.then(fn), Promise.resolve())

Równolegle

await Promise.all(items.map(async item => { await fetchItem(item) }))

Zalety: Szybciej. Wszystkie iteracje zostaną wykonane, nawet jeśli jedna się nie powiedzie.

Kolejno

for (let i = 0; i < items.length; i++) {
    await fetchItem(items[i])
}

Zalety: Zmienne w pętli mogą być współużytkowane przez każdą iterację. Zachowuje się jak normalny imperatywny kod synchroniczny.

Odpowiedź Bergisa sprawiła, że ​​znalazłem się na właściwej drodze, używając Array.reduce.

Jednak, aby faktycznie uzyskać funkcje zwracające moje obietnice wykonania jedna po drugiej, musiałem dodać więcej zagnieżdżenia.

Mój prawdziwy przypadek użycia to tablica plików, które muszę przesłać w kolejności jeden po drugim ze względu na ograniczenia w dół ...

Oto, z czym skończyłem.

getAllFiles().then( (files) => {
    return files.reduce((p, theFile) => {
        return p.then(() => {
            return transferFile(theFile); //function returns a promise
        });
    }, Promise.resolve()).then(()=>{
        console.log("All files transferred");
    });
}).catch((error)=>{
    console.log(error);
});

Jak sugerują poprzednie odpowiedzi, użyj:

getAllFiles().then( (files) => {
    return files.reduce((p, theFile) => {
        return p.then(transferFile(theFile));
    }, Promise.resolve()).then(()=>{
        console.log("All files transferred");
    });
}).catch((error)=>{
    console.log(error);
});

nie czekał na zakończenie przesyłania przed rozpoczęciem kolejnego, a tekst „Wszystkie przesłane pliki” pojawił się jeszcze przed rozpoczęciem przesyłania pierwszego pliku.

Nie jestem pewien, co zrobiłem źle, ale chciałem się podzielić tym, co zadziałało.

Edycja: Odkąd napisałem ten post, teraz rozumiem, dlaczego pierwsza wersja nie działała. then () oczekuje funkcji zwracającej obietnicę. Więc powinieneś podać nazwę funkcji bez nawiasów! Teraz moja funkcja potrzebuje argumentu, więc muszę zawinąć w anonimową funkcję nie pobierającą żadnego argumentu!

tylko po to, aby rozwinąć odpowiedź @ Bergi (która jest bardzo zwięzła, ale trudna do zrozumienia;)

Ten kod uruchomi każdy element w tablicy i doda następny łańcuch „then chain” na końcu;

function eachorder(prev,order) {
        return prev.then(function() {
          return get_order(order)
            .then(check_order)
            .then(update_order);
        });
    }
orderArray.reduce(eachorder,Promise.resolve());

mam nadzieję, że to ma sens.

Możesz również przetwarzać iterowalne sekwencyjnie z funkcją asynchroniczną, używając funkcji rekurencyjnej. Na przykład biorąc pod uwagę tablicę ado przetworzenia z funkcją asynchroniczną someAsyncFunction():

var a = [1, 2, 3, 4, 5, 6]

function someAsyncFunction(n) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("someAsyncFunction: ", n)
      resolve(n)
    }, Math.random() * 1500)
  })
}

//You can run each array sequentially with: 

function sequential(arr, index = 0) {
  if (index >= arr.length) return Promise.resolve()
  return someAsyncFunction(arr[index])
    .then(r => {
      console.log("got value: ", r)
      return sequential(arr, index + 1)
    })
}

sequential(a).then(() => console.log("done"))

Za pomocą async await tablicę obietnic można łatwo wykonać sekwencyjnie:

let a = [promise1, promise2, promise3];

async function func() {
  for(let i=0; i<a.length; i++){
    await a[i]();
  }  
}

func();

Uwaga: W powyższej implementacji, jeśli obietnica zostanie odrzucona, reszta nie zostanie wykonana.Jeśli chcesz, aby wszystkie obietnice zostały wykonane, zawiń swoje await a[i]();wnętrzetry catch

równolegle

zobacz ten przykład

const resolveAfterTimeout = async i => {
  return new Promise(resolve => {
    console.log("CALLED");
    setTimeout(() => {
      resolve("RESOLVED", i);
    }, 5000);
  });
};

const call = async () => {
  const res = await Promise.all([
    resolveAfterTimeout(1),
    resolveAfterTimeout(2),
    resolveAfterTimeout(3),
    resolveAfterTimeout(4),
    resolveAfterTimeout(5),
    resolveAfterTimeout(6)
  ]);
  console.log({ res });
};

call();

uruchamiając kod, będzie konsolidował "CALLED" dla wszystkich sześciu obietnic, a kiedy zostaną rozwiązane, będzie konsolidował co 6 odpowiedzi po przekroczeniu limitu czasu w tym samym czasie

NodeJS nie uruchamia obietnic równolegle, uruchamia je jednocześnie, ponieważ jest to architektura pojedynczej pętli zdarzeń. Istnieje możliwość równoległego uruchamiania, tworząc nowy proces potomny w celu wykorzystania wielordzeniowego procesora.

Równoległe kontra współbieżne

W rzeczywistości Promise.alljest to zestawianie funkcji obietnic w odpowiedniej kolejce (patrz architektura pętli zdarzeń), uruchamianie ich jednocześnie (wywołanie P1, P2, ...), a następnie czekanie na każdy wynik, a następnie rozwiązanie Promise. Wszystko ze wszystkimi obietnicami wyniki. Obietnica. Wszystko zawiedzie przy pierwszej obietnicy, która zawodzi, chyba że sam poradzisz sobie z odrzuceniem.

Istnieje zasadnicza różnica między równoległym i współbieżnym, pierwszy z nich będzie wykonywał różne obliczenia w oddzielnym procesie dokładnie w tym samym czasie i będą postępować w tym rytmie, podczas gdy drugi wykona różne obliczenia jeden po drugim, nie czekając na poprzednie obliczenia, aby zakończyć i postępować w tym samym czasie, bez uzależnienia od siebie nawzajem.

Wreszcie, aby odpowiedzieć na twoje pytanie, Promise.allnie zostanie wykonany ani równolegle, ani sekwencyjnie, ale równolegle.

Odpowiedź Bergiego pomogła mi uczynić wywołanie synchronicznym.Dodałem poniżej przykład, w którym wywołujemy każdą funkcję po wywołaniu poprzedniej funkcji.

function func1 (param1) {
    console.log("function1 : " + param1);
}
function func2 () {
    console.log("function2");
}
function func3 (param2, param3) {
    console.log("function3 : " + param2 + ", " + param3);
}

function func4 (param4) {
    console.log("function4 : " + param4);
}
param4 = "Kate";

//adding 3 functions to array

a=[
    ()=>func1("Hi"),
    ()=>func2(),
    ()=>func3("Lindsay",param4)
  ];

//adding 4th function

a.push(()=>func4("dad"));

//below does func1().then(func2).then(func3).then(func4)

a.reduce((p, fn) => p.then(fn), Promise.resolve());

Możesz to zrobić za pomocą pętli for.

obietnica zwrotu funkcji async

async function createClient(client) {
    return await Client.create(client);
}

let clients = [client1, client2, client3];

jeśli napiszesz następujący kod, klient zostanie utworzony równolegle

const createdClientsArray = yield Promise.all(clients.map((client) =>
    createClient(client);
));

wtedy wszyscy klienci są tworzeni równolegle. ale jeśli chcesz stworzyć klienta sekwencyjnie, powinieneś użyć pętli for

const createdClientsArray = [];
for(let i = 0; i < clients.length; i++) {
    const createdClient = yield createClient(clients[i]);
    createdClientsArray.push(createdClient);
}

następnie wszyscy klienci są tworzeni sekwencyjnie.

miłego kodowania :)

Używałem for do rozwiązywania kolejnych obietnic. Nie jestem pewien, czy to pomaga, ale właśnie to robiłem.

async function run() {
    for (let val of arr) {
        const res = await someQuery(val)
        console.log(val)
    }
}

run().then().catch()

to może odpowiedzieć na część twojego pytania.

tak, możesz połączyć tablicę funkcji zwracających obietnice w następujący sposób ... (spowoduje to przekazanie wyniku każdej funkcji do następnej). możesz oczywiście edytować go, aby przekazać ten sam argument (lub żadnych argumentów) do każdej funkcji.

function tester1(a) {
  return new Promise(function(done) {
    setTimeout(function() {
      done(a + 1);
    }, 1000);
  })
}

function tester2(a) {
  return new Promise(function(done) {
    setTimeout(function() {
      done(a * 5);
    }, 1000);
  })
}

function promise_chain(args, list, results) {

  return new Promise(function(done, errs) {
    var fn = list.shift();
    if (results === undefined) results = [];
    if (typeof fn === 'function') {
      fn(args).then(function(result) {
        results.push(result);
        console.log(result);
        promise_chain(result, list, results).then(done);
      }, errs);
    } else {
      done(results);
    }

  });

}

promise_chain(0, [tester1, tester2, tester1, tester2, tester2]).then(console.log.bind(console), console.error.bind(console));

Natknąłem się na tę stronę, próbując rozwiązać problem w NodeJS: ponowny montaż fragmentów plików. Zasadniczo: mam tablicę nazw plików. Muszę dołączyć wszystkie te pliki we właściwej kolejności, aby utworzyć jeden duży plik. Muszę to zrobić asynchronicznie.

Moduł 'fs' węzła zapewnia appendFileSync, ale nie chciałem blokować serwera podczas tej operacji. Chciałem użyć modułu fs.promises i znaleźć sposób na połączenie tych rzeczy razem. Przykłady na tej stronie nie do końca działały dla mnie, ponieważ faktycznie potrzebowałem dwóch operacji: fsPromises.read () do wczytania fragmentu pliku i fsPromises.appendFile () do połączenia z plikiem docelowym. Może gdybym był lepszy z javascriptem, mógłbym sprawić, że poprzednie odpowiedzi działałyby dla mnie. ;-)

Natknąłem się na to ... https://css-tricks.com/why-using-reduce-to-sequably-resolve-promises-works/ ... i udało mi się zhakować razem działające rozwiązanie.

TLDR:

/**
 * sequentially append a list of files into a specified destination file
 */
exports.append_files = function (destinationFile, arrayOfFilenames) {
    return arrayOfFilenames.reduce((previousPromise, currentFile) => {
        return previousPromise.then(() => {
            return fsPromises.readFile(currentFile).then(fileContents => {
                return fsPromises.appendFile(destinationFile, fileContents);
            });
        });
    }, Promise.resolve());
};

A oto test jednostkowy jaśminu:

const fsPromises = require('fs').promises;
const fsUtils = require( ... );
const TEMPDIR = 'temp';

describe("test append_files", function() {
    it('append_files should work', async function(done) {
        try {
            // setup: create some files
            await fsPromises.mkdir(TEMPDIR);
            await fsPromises.writeFile(path.join(TEMPDIR, '1'), 'one');
            await fsPromises.writeFile(path.join(TEMPDIR, '2'), 'two');
            await fsPromises.writeFile(path.join(TEMPDIR, '3'), 'three');
            await fsPromises.writeFile(path.join(TEMPDIR, '4'), 'four');
            await fsPromises.writeFile(path.join(TEMPDIR, '5'), 'five');

            const filenameArray = [];
            for (var i=1; i < 6; i++) {
                filenameArray.push(path.join(TEMPDIR, i.toString()));
            }

            const DESTFILE = path.join(TEMPDIR, 'final');
            await fsUtils.append_files(DESTFILE, filenameArray);

            // confirm "final" file exists    
            const fsStat = await fsPromises.stat(DESTFILE);
            expect(fsStat.isFile()).toBeTruthy();

            // confirm content of the "final" file
            const expectedContent = new Buffer('onetwothreefourfive', 'utf8');
            var fileContents = await fsPromises.readFile(DESTFILE);
            expect(fileContents).toEqual(expectedContent);

            done();
        }
        catch (err) {
            fail(err);
        }
        finally {
        }
    });
});

Mam nadzieję, że to komuś pomoże.