mit async korrekt (mit forEach)

Erstens, es gibt keine async.forEach, aber es ist die async.each Funktion. Die async.parallel Funktion führen Sie alle Aufgaben simoultaneously und führen Sie dann den Rückruf, sofern Sie definiert wurde.

In Ihre Quelle, die callback - Funktion wird ausgeführt, sobald die async.parallel ausgeführt wird, nicht nach allen seinen Funktionen zurück. Ich schlage vor, Sie Lesen die Dokumentation.

Wenn Sie möchten, führen Sie die callback nach all den parallelen Funktionen " Rückrufe wurden aufgerufen, Sie sollten vergehen, die forEach's Rückruf der async.parallel Funktion als zweiten parameter, nachdem Sie das array von Funktionen. Auch, sollten Sie sich wahrscheinlich übergeben, die Rückrufe zu beiden databaseCallA und databaseCallB damit rufen Sie Ihre Rückrufe, wenn Sie fertig sind, so dass Sie nicht ausgeführt vorzeitig.

async.each(array, function(elem, callback) {
    async.parallel([
        function(cb) {
            databaseCallA(cb);
            //if you have called the cb here, the `async.parallel` function would "think" that the databaseCallA has finished, even though it may not have started yet.
        },
        function(cb) {
            databaseCallB(cb):
        } 
    ], callback);
});

Bearbeiten Sie Ihre Datenbank-Funktionen aufrufen zu akzeptieren, die callback-argument und machen Sie den Aufruf der callback-nachdem Sie Ihre Arbeit getan.

Den Punkt der asynchronen Aufrufe wird kostenlos die Ressourcen für andere Tätigkeiten während der Wartezeit für Ihre Aufgabe zu beenden - Ihr code wird weiterhin, es ist die Ausführung, aber Sie können die Rückrufe oder irgendeine Art von Ereignis-basierte Benachrichtigungen, die anderen die asynchrone Aufgabe abgeschlossen ist.

BEARBEITEN

Ausführen etwas, nachdem alle parallelen Anrufe beendet haben:

async.each(array, function(elem, callback) {
    async.parallel([
        function(cb) {
            //I use the setTimeout function to intentionally
            //delay the response
            setTimeout(function() {
                //the first cb parameter is error, the second is result 
                //in case there was no error
                cb(undefined, 'a');
            }, 500);
        },
        function(cb) {
            setTimeout(function() {
                cb(undefined, 'b');
            }, 300);
        },
        function(cb) {
            setTimeout(function() {
                cb(undefined, 'c');
            }, 800);
        }
    ], function(err, results) {
        //this will be executed only after all three cb's are executed. In
        //this case, after about 800ms. The results variable will be an 
        //array containing the resuts passed to each cb. In this case it
        //will  be ['a', 'b', 'c'].

        //you could call the main callback here
        callback();
    });
}, function(err) {
    //this callback will be executed either after everything was done,
    //or if an error has occurred.
    if (err) {
        handleError(err);
        return;
    }

    //this should be executed after all `each` and `parallel` calls
    //have finished. In this case, it should also be after about 800ms
    //from the start, since everything was executed in parallel
    console.log('finished');

    //now you are sure everything was done, do something afterwards
    after();
});

//this will be executed immediately so don't put anything here
//that depends on the outcome of the async calls above
console.log('test');