NodeJS的异步、并发编程方案

一、事件发布/订阅模式（events）

事件发布/订阅模式自身并无同步和异步的问题，但在node中，emit()调用多半是伴随时间循环而异步触发的。
订阅：

emitter.on("event1", function(message){
    console.log(message);
});

发布

emitter.emit("event1","I am message")

注意事项：
- 如果对一个事件添加了超过10个侦听器，将会得到一条警告。因为如果事件相关的监听器过多，可能会导致CPU占用过多。
- 一个健壮的EventEmitter实例应该对error对象做处理

雪崩问题：在高访问量、大并发量的情况下缓存失效的场景，此时大量的请求同时涌入数据库中，数据库无法同时承受如此大的查询请求，进而影响到网站整体的响应速度。

解决方法：引入事件队列

var proxy = new events.EventEmitter();
var status = "ready";
var select = function(callback){
    proxy.once("selected", callback);
    if (status === "ready"){
        status = "spending";
        db.select("SQL", function(results){
            status = "ready";
            callback(results);
        })
    }
}

这里我们利用了once()方法，将所有请求的回调都压入事件队列中，利用其执行一次就会将监听器移除的特点，保证每一次回调只会被执行一次。这样就保证了，对于相同的SQL语句，同一个查询开始到结束的过程永远只有一次。一旦查询结束，得到的结果可以被这些调用者共同使用。
另外，此处可能因为存在监听器躲过而引发警告，需要调用下边的代码移除警告

setMaxListeners(0)

多异步之间的协作方案：利用偏函数来处理哨兵变量和第三方函数的关系

var emitter = new events.Emitter();
var done = after(times, render);

// 多对多
emitter.on("done", done);
emitter.on("done", other);

var after = function(times, callback){
    var count = 0, results = {};
    return function (key, value) {
        results[key] = value;
        count ++;
        if (count === times){
            callback(results);
        }
    }
}

db.query(sql, function(err, data){
    emitter.emit("done", "data", data)
});
fs.readFile(template_path, "utf-8", function(err, template){
    emitter.emit("done", "template", template);
})

EventProxy的应用

all()方法：当all()方法中订阅的多个事件都被触发后，才会执行侦听器。

var ep = new EventProxy();
ep.all("template", "data", function(template, data){
    // TODD
});
fs.readFile(template_path, "utf-8", function(err, template){
    ep.emit("template", template);
})
db.query(sql, function(err, data){
    ep.emit("data", data);
})

注意：all()方法订阅的事件如果没有返回值，则应最后订阅该事件。因为侦听器会按订阅事件的顺序接收返回值。

tail()方法：tail()方法与all()方法的区别在于：all()方法的侦听器在满足条件后只会执行一次，tail()方法的侦听器在满足条件执行一次后，如果组合事件中的某个事件再次触发，侦听器会用最新的数据继续执行。

after()方法：实现事件在执行多少次之后执行侦听器的单一事件组合订阅方式

ep.after("data", 10, function(datas){
    // TODD
})

异常处理：EventProxy提供了fail()和done()这两个实例方法来优化异常处理

ep.fail(callback)

等价于

ep.fail(function(err){
    callback(err);
});

又等价于

ep.bind('error', function(err){
    // 卸掉所有处理函数
    ep.unbind();
    // 异常回调
    callback(err);
});

而done()方法的实现，也可参见如下变换：

ep.done('tp1');

它等价于：

function(err, content){
    if(err){
        return ep.emit('error', err);
    }
    ep.emit('tp1', content);
}

当传递参数为回调函数时，需手动调用emit()触发事件

ep.done(function (content){
    // TODD
    // 无需考虑异常
    ep.emit('tp1', content)
})

改进：同时传入事件名称和回调函数

ep.done('tp1', function(content){
    // TODD
    return content;
})

二、Promise/Deferred模式（Promises/A）

这里写图片描述

让Promise支持链式执行，主要通过以下两个步骤

将所有的回调都存到队列中
Promise完成时，逐个执行回调，一旦监测到返回了新的Promise对象，停止执行，然后将当前Deffered对象的promies引用改变为新的Promise对象，并将队列中剩余的回调转交给它

实例代码

new Promise(test).then(function (result1) {
    console.log('成功1：' + result1);
}).then(function (result2) {
    console.log('成功2：' + result2);
}).catch(function (reason) {
    console.log('失败：' + reason);
});

推荐廖雪峰的博客

三、流程控制库

尾触发与Next：

尾触发目前应用最多的地方是Connect的中间件

var app = connect();
app.use(connect.staticCache());
app.use(connect.static(__dirname + '/public'));
app.use(connect.cookieParser());
app.use(connect.session());
app.use(connect.query());
app.use(connect.bodyParser());
app.use(connect.csrf());
app.listen(3001);

通过use()方法注册好一系列中间件后，监听端口上的请求。中间件利用了尾触发的机制，最简单的中间件如下：

function(req, res, next){
    // 中间件
}

每个中间件传递请求对象、相应对象和尾触发函数，通过队列形成一个处理流
这里写图片描述

async
async提供了series()方法来实现一组任务的串行执行

async.series([
    function(callback){
        fs.readFile('file1.txt', 'utf-8', callback);
    },
    function (callback){
        fs.readFile('file2.txt', 'utf-8', callback);
    }
],
    function(err, results){
    // results => [file1.txt, file2.txt]
})

等价于

fs.readFile('file1.txt', 'utf-8', function (err, content){
    if (err){
        return callback(err);
    }
    fs.readFile('file2.txt', 'utf-8', callback (err, data){
        if (err){
            return callback(err)
        }
        callback( null, [content, data]);
    });
})

callback()并非由指定者指定。每个callback()执行时会将结果保存起来，然后执行下一个调用。一旦出现异常，就结束调用，并将异常传递给最终回调函数的第一个参数。

异步的并行执行：async的parallel()方法

async.parallel([
    function(callback){
        fs.readFile('file1.txt', 'utf-8', callback);
    },
    function (callback){
        fs.readFile('file2.txt', 'utf-8', callback);
    }
],
    function(err, results){
    // results => [file1.txt, file2.txt]
})

异步调用的依赖处理：series()适合五一来的异步串行执行，但当前一个结果是后一个调用的输入时，series()方法就无法满足需求了。async提供了waterfall()方法。

async.waterfall([
    function(callback){
        fs.readFile('file1.txt', 'utf-8', function(err, content){
            callback(err, content);
        })
    },
    function (arg1, callback){
        // arg1 => file2.txt
        fs.readFile(arg1, 'utf-8', function(err, content){
            callback(err, content);
        })
    },
    function (arg2, callback){
        // arg2 => file3.txt
        fs.readFile(arg2, 'utf-8', function(err, content){
            callback(err, content);
        })
    }
],function (err, result){
    // result => file4.txt
})

自动依赖处理：async提供了一个强大的方法auto()实现复杂的业务处理
假设业务场景为：

从磁盘读取配置文件
根据配置文件链接MongoDB
根据配置文件链接Redis
编译静态文件
上传静态文件到CDN
启动服务器

简单映射下上述任务:

{
    readConfig: function(){},
    connectMongoDB: function(){},
    connectRedis: function(){},
    compileAsserts: function(){},
    uploadAsserts: function(){},
    startup: function(){}
}

connectMongoDB和connectRedis依赖readConfig，uploadAsserts依赖compileAsserts，startup依赖所有。

var deps = {
    readConfig : function (callback){
        // read config file
        callback();
    },
    connectMongoDB: ['readConfig', function(callback){
        // connect to mongodb
        callback();
    }],
    connectRedis: ['readConfig', function(callback){
        // connect to redis
        callback();
    }],
    compileAsserts: function(callback){
        // compile asserts
        callback();
    },
    uploadAsserts: ['compileAsserts', function(callback){
        // upload to assert
        callback();
    }],
    startup: ['connectMongoDB', 'connectRedis', 'uploadAsserts', function(callback){
        // startup
    }]
}
async.auto(deps);

用EventProxy实现

ep.asap('readtheconfig', function(){
    // read config file
    ep.emit('readConfig');
}).on('readConfig', function(){
    // connect to mongodb
    ep.emit('connectMongoDB');
}).on('readConfig', function(){
    // connect to redis
    ep.emit('connectRedis');
}).assp('compiletheasserts', function(){
    // compile assert
    ep.emit('compileAsserts');
}).on('compileAsserts', function(){
    // upload to assert
    ep.emit('uploadAsserts');
}).all('connectMongoDB', 'connectRedis', 'compileAsserts', function(){
    // startup
});

Step: 比async更轻量，只有一个接口Step

Step(
    function readFile1(){
        fs.readFile('file1.txt', 'utf-8', this);
    },
    function readFile2(){
        fs.readFile('file2.txt', 'utf-8', this);
    },
    function done(err, content){
        console.log(content);
    }
)

用到了this关键字，是Step内部的一个next()方法，将异步调用的结果传递给下一个任务作为参数，并调用执行。

并行任务执行：Step中可以调用this的parallel()方法，告诉Step需要等所有任务完成时才进行下一个任务

Step(
    function readFile(){
        fs.readFile('file1.txt', 'utf-8', this.parallel());
        fs.readFile('file2.txt', 'utf-8', this.parallel());
    }，
    function done(err, content1, content2){
        // content1 => file1
        // content2 => file2
        console.log(arguments);
    }
)

使用parallel()时，如果异步方法的结果返回的是多个参数，Step只会取前两个参数。

结果分组：类似parallel()的效果，但在结果传递上不同：返回值以数据形式返回。主要用于遍历某个方法，然后将结果存入数组中。而parallel()更适合同时运行两个异步函数。

Step(
    function readDir(){
        fs.readdir(__dirname, this);
    },
    function readFile(err, results){
        if (err) throw err;
        // 创建组
        var group = this.group();
        results.forEach(function (filename){
            if (/\.js$/.test(filename)){
                fs.readFile(__dirname + "/" + filename, 'utf-8', group());
            }
        });
    },
    function showAll(err, files){
        if (err) thow err;
        console.dir(files);
    }
)

异步并发控制

bagpipe的解决方案

通过一个队列来控制并发量
如果当前活跃的异步调用量小于限定值，从队列中取出执行
如果活跃调用达到限定值，调用暂时存在队列中
每个异步调用结束时，从队列中取出新的异步调用执行

bagpipe的API主要暴露了一个push()方法和pull事件，实例代码如下：

var Bagpipe = require('bagpipe');
// 设定最大并发数为10
for (var i = 0; i < 100; i++){
    bagpipe.push(async, function(){
        // 异步回调执行
    })
}
bagpipe.on('full', function(length){
    console.warn("目前队列长度为：", length);
})

拒绝模式：有些场景需要尽快返回数据，快速成功获取数据或者失败，即立即返回数据。这时候可以用bagpipe的拒绝模式。

// 设置最大并发数为10
var bagpipe = new Bagpipe(10, {
    refuse: true
})

在拒绝模式下，如果等待的调用队列也满了之后，新来的调用就直接返回拒绝异常

超时限制：为了防止某些异步调用使用太长的时间，我们需要设置一个时间基线，将那些执行时间太久的异步调用清理出活跃队列，让排队中的异步调用尽快执行，否则在拒绝模式下，会有太多调用因为某个执行的慢，导致得到拒绝异常。

// 设置最大并发数
var bagpipe = new Bagpipe(10, {
    // 设置超时限制为3s
    timeout: 3000
})

——-总结自《深入浅出NodeJS》

ES6中async的用法
async函数返回一个Promise对象,可以使用then方法添加回调函数.当函数执行时,遇到await就会等待其异步操作完成,然后执行函数体后面的语句
1.async放在函数前,表示函数里有异步操作.
如:

async function foo(){} //函数声明
或
const foo = async function foo(){} // 函数表达式

2.async函数的返回值为Promise对象

async function f(){
  return 'hello world';
}
f().then(v => console.log(v));
// "hello world"

async function f(){
  throw new Error('报错了'); // 返回的Promise对象为reject状态
}
f().then(
  v => console.log(v),
  e => console.log(e)
);
// Error: 报错了

// 用catch接受错误信息
async function f(){
  throw new Error('报错了');
}
f()
.then(v => console.log(v))
.catch(e => console.log(e))
// Error: 报错了

3.await表示紧跟在后面的表达式需要等待结果.一般为Promise对象,如果不是,会被转成一个立即resolve的Promise对象
4. 防止异步函数出错,需要把await命令放在try…catch代码块中.和for循环一起用可实现重复尝试某函数.如网络原因可能发送邮件失败,尝试多次发送,捕捉失败原因,一旦成功,break结束循环.

function test2(){
  setTimeout(()=>{
    console.log(1000);
  },1000)
}

async function test(){
  for(let i = 0; i < 5; i++){
    try {
      await test2(); // 异步函数
      break

    } catch (e) {
      console.log('a', e);
    }
  }

}
test();