Detect the end of multiple async loops [duplicate]

I have a loop that calls several sync functions simultaneously and in parallel. When they are all done, a series of final operations must be called to end the program.

For example, look at this simple code:

(async () => { var items = [1, 2, 3, 4, 5]; for (var item of items) { console.log('Running... #' + item); var loop = async function(item) { var delay = getRandom(3, 7)*1000; await sleep(delay); console.log('Done. #' + item + ' with delay: ' + delay); } loop(item); } //while (true) {await sleep(1000);} console.log('Finish'); })(); /////////////////////////////////////// async function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } function getRandom(min, max) { min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1) + min); } 

The output is as follows:

Running... #1 Running... #2 Running... #3 Running... #4 Running... #5 Finish Done. #5 with delay: 3000 Done. #2 with delay: 4000 Done. #4 with delay: 6000 Done. #1 with delay: 7000 Done. #3 with delay: 7000 

Which is not good, because "Finish" is printed before the end of all the loops.
Note that "Finish" is an example, and here I may have final operations such as closing a database or browser, and so on.

If I call the functions like this:

await loop(item); 

Result:

Running... #1 Done. #1 with delay: 3000 Running... #2 Done. #2 with delay: 7000 Running... #3 Done. #3 with delay: 6000 Running... #4 Done. #4 with delay: 6000 Running... #5 Done. #5 with delay: 5000 Finish 

The phrase "Finish" is printed well at the end, but instead all my functions are executed async and in order, which is not desirable.

Another way I tried is to use an infinite While similar to the one I commented on in the source code:

while (true) {await sleep(1000);} 

Result:

Running... #1 Running... #2 Running... #3 Running... #4 Running... #5 Done. #1 with delay: 3000 Done. #5 with delay: 4000 Done. #3 with delay: 6000 Done. #4 with delay: 6000 Done. #2 with delay: 7000 

The operation is correct here, but it never reaches "Finish".

Another way I thought of was to put a counter at the end of the functions and put a condition inside the end loop to control it and exit the loop.

like this:

(async () => { var items = [1, 2, 3, 4, 5]; var n = 0; // <==== for (var item of items) { console.log('Running... #' + item); var loop = async function(item) { var delay = getRandom(3, 7)*1000; await sleep(delay); console.log('Done. #' + item + ' with delay: ' + delay); n++; // <==== } loop(item); } while (true) { await sleep(1000); if (n == items.length) break; // <==== } console.log('Finish'); })(); 

And its output:

Running... #1 Running... #2 Running... #3 Running... #4 Running... #5 Done. #2 with delay: 3000 Done. #1 with delay: 4000 Done. #5 with delay: 4000 Done. #3 with delay: 5000 Done. #4 with delay: 6000 Finish 

This is my expected and desired output. But I think the solution is not clean! Because the counter is difficult to control in the program, and maybe in some places I needed to return from the function and I should always be careful to increase n by one.

So I think there should be a simpler and more principled solution to achieve this goal. Maybe, for example, putting all the call results in an array and checking it in While, but as much as possible I do not want to change the structure of my program, and it is better to add everything simply and at the end of the code.

Do you have a solution?