async.parallel 和 async.map 可以帮上忙。 试试下面的代码，没有环境未测试，大概是这个意思。

async.parallel([
    function(callback) { // task#1
        async.map(role, function(name, cb) {
            redisClient.get(name,function(err,roleReply){
                 cb(err, roleReply);
            });
        }, function(err, roles) {
                callback(err, roles);     
        });
    },
    function(callback){  // your second task
       
    }
],
function(err, results){
   // go and play with results
   
});

@hsh075623201 感觉没有问题，你实际使用一下吧。

getValuesByKey.getValue.bind(getValuesByKey)在你的情况下似乎没有必要，因为不存在getValue()没有使用this，可以简单地试着写成：

function getValue(key,  callback) {
        ....
}

async.map(redisKey, getValue, function (err, result) {
   ...
});

或直接匿名：

async.map(redisKey, function(key, callback) {
        ...
}, function (err, result) {
   ...
});

@hsh075623201 从你给出来的代码，不太能看到错误。

    menuPage.save();  // 同步的还是异步的？感觉应该是异步
    callback(null);          // 如果是的话，callback可能会在menuPage保存完成前调用

另外： 将menuPages存入数据库 ，然后 返回success – 在这种情况下，你似乎不需要每个menuPage保存后的返回值，因此，可以不使用async.map而是使用async.each。

简单写了个例子:

var mongoose = require('mongoose'),
    Schema = mongoose.Schema;
var async = require('async');

mongoose.connect('mongodb://localhost:27017/test');

// define model
var User = mongoose.model('User', new Schema({
                                    name: String
                                  }));

// create users
var users = [];
for (var i = 0; i < 5; ++i) {
  users.push({ name: 'user#' + i });
}

// and save them
async.each(users, function (user, callback) {
  User.create(user, function (err, user) {
    callback(err);
  });
}, function (err) {
  if (err) {
    console.log('Error: ' + err);
  } else {
    console.log('Done');
  }

  // disconnect if you intend to
  // mongoose.disconnect();
});

执行后查看数据库:

> db.users.find().pretty();
{
    "name" : "user#0",
    "_id" : ObjectId("53a1ad5d400b2aa6044c7afd"),
    "__v" : 0
}
{
    "name" : "user#2",
    "_id" : ObjectId("53a1ad5d400b2aa6044c7aff"),
    "__v" : 0
}
{
    "name" : "user#1",
    "_id" : ObjectId("53a1ad5d400b2aa6044c7afe"),
    "__v" : 0
}
{
    "name" : "user#3",
    "_id" : ObjectId("53a1ad5d400b2aa6044c7b00"),
    "__v" : 0
}
{
    "name" : "user#4",
    "_id" : ObjectId("53a1ad5d400b2aa6044c7b01"),
    "__v" : 0
}

@hsh075623201

导致还没保存完 就调用callback

User.create(user, function (err, user) {
    callback(err);   // 这个callback是对保存数组中的每一项的回调 -- 这里就是这个user的处理是否成功还是有错误
                     // 而不是针对这个数组中的所有元素是否处理完成的
});

所有元素处理完毕的回调在这里：

 function (err) {  // 所有元素处理完毕了（也不见得一定是处理了所有元素）
  if (err) {            // 如果处理某个元素时错误（callback(err) 时，这个err不为空），会立马跳到这里
                        // 并且这里的err就是callback(err)时的那个err 
    console.log('Error: ' + err);
  } else {   // 如果执行到了这里，表示数组中的所有元素已经成功地处理完毕
    console.log('Done');
  }

附上async.each的源码，你体会一下：

    async.each = function (arr, iterator, callback) {
        callback = callback || function () {};    
        if (!arr.length) {   // 如果给的不是array-like参数
            return callback();  // 直接回调，做不下去了
        }
        var completed = 0;       // 计数，有多少个元素被成功处理了
        _each(arr, function (x) {       // 遍历arr中的所有元素 (_each只是利用了Array.prototype.forEach
                                        //  或自己for循环遍历（如果Array.prototype.forEach不存在）)
            iterator(x, only_once(done) );  // 调用你的迭代函数处理数组中的每一个元素, 这个调用决定了
                                            // 1) 你的迭代函数的第一个参数是数组中的某元素
                                            // 2) 你的迭代函数的第二个参数是一个函数（值为only_once(done)）
                                            //      only_once保证了你只能调用这个函数至多一次。根据函数done的实现，你必须
                                            //      在你的迭代函数中调用他一次，无论成功还是失败，否则计数completed在没有错误的情况
                                            //      下不会+1, 导致最终的callback不能执行 -- 具体看done函数
        });
        function done(err) {
          if (err) {   // 如果有错，立马回调 -- 报错
              callback(err);
              callback = function () {};  // 保证callback也只能被执行一次（想象如果有多个错误同时回调的情况）
          }
          else {
              completed += 1;         // 没错，计数+1
              if (completed >= arr.length) {  // 如果所有的处理都没有错
                  callback();     // 回调，处理完毕且无错误
              }
          }
        }
    };