1.串行无关联：async.series(tasks,callback);
多个函数依次执行,之间没有数据交换,其中一个函数出错，后续函数不再执行
async.series({
one: function(callback){
callback(null, 1);
},
two: function(callback){
callback(null, 2);
}
},function(err, results) {
console.log(results);
});
例：交叉执行
//-------------n13_async.js------------------------------
function oneFun()
{
/*
setTimeout(function(){ },1000);
*/
ii=0;
setInterval(function(){
console.log("aaa="+new Date());
ii++;
if(ii==3){
clearInterval(this);
}
},1000);
console.log("oneFun");
}
function twoFun()
{
jj=0;
setInterval(function(){
console.log("bbb="+new Date());
jj++;
if(jj==3){
clearInterval(this);
}
},1000);
console.log("oneFun执行完毕");
} oneFun(0);console.log("oneFun执行");
twoFun();
console.log("twoFun执行");
console.log("主进程执行完毕");
//-------------n13_async.js------------------------------
var async = require('async');
function exec(){
async.series({
one: function(done){
ii=0;
setInterval(function(){
console.log('aaa='+new Date());
ii++;
if(ii==3){
clearInterval(this);
done(null,{one:"one"});
}
},1000);
},
two: function(done){
jj=0;
setInterval(function(){
console.log('bbb='+new Date());
jj++;
if(jj>3){
clearInterval(this);
done(null,{two:"two"});
}
},1000);
}
},
function(err,rs) {
console.log(err);
console.log(rs);
});
}
exec(); 2.并行无关联：async.parallel(tasks,callback);
多个函数并行执行，最后汇总结果,如果某一个流程出错就退出
async.parallel({
one: function(callback){
callback(null, 1);
},
two: function(callback){
callback(null, 2);
}
},function(err, results) {
console.log(results);
});
3.串行有关联:waterfall
每一步执行时需要由上一步执行的结果当做参数.所以每一步必须串行等待
async.waterfall([
function (done) { done(null, 'one');
},
function (onearg, done) { done(null, onearg + '| two');
},
function (twoarg, done) { done(null, twoarg + '| three');
},
function (threearg, done) { done(null, threearg + '| four');
}
], function (error, result) {
console.log(result);
console.timeEnd('waterfall');
})
例子：
function exec(){
async.waterfall(
[
function(done){
ii=0;
setInterval(function(){
console.log("aaa="+new Date());
ii++;
if(ii==3){
clearInterval(this);
done(null,'one完毕');
}
},1000);
},
function(preValue,done){
jj=0;
setInterval(function(){
console.log(preValue+"="+new Date());
jj++;
if(jj==3){
clearInterval(this);
done(null,preValue+',two完毕');
}
},1000); }
],function(err,rs){
console.log(err);
console.log(rs);
}
)
} 4.parallelLimit(tasks, limit, [callback]) parallelLimit函数和parallel类似，但是它多了一个参数limit。
limit参数限制任务只能同时并发一定数量，而不是无限制并发, async.parallelLimit([
function(callback){
callback(null, 'one');
},
function(callback){
callback(null, 'two');
}
],
2, //只允许同时有两个函数并行
function(err, results){
console.log(results);
});
1.串行无关联：async.series(tasks,callback);
多个函数依次执行,之间没有数据交换,其中一个函数出错，后续函数不再执行
async.series({
one: function(callback){
callback(null, 1);
},
two: function(callback){
callback(null, 2);
}
},function(err, results) {
console.log(results);
});
例：交叉执行
//-------------n13_async.js------------------------------
function oneFun()
{
/*
setTimeout(function(){ },1000);
*/
ii=0;
setInterval(function(){
console.log("aaa="+new Date());
ii++;
if(ii==3){
clearInterval(this);
}
},1000);
console.log("oneFun");
}
function twoFun()
{
jj=0;
setInterval(function(){
console.log("bbb="+new Date());
jj++;
if(jj==3){
clearInterval(this);
}
},1000);
console.log("oneFun执行完毕");
} oneFun(0);console.log("oneFun执行");
twoFun();
console.log("twoFun执行");
console.log("主进程执行完毕");
//-------------n13_async.js------------------------------
var async = require('async');
function exec(){
async.series({
one: function(done){
ii=0;
setInterval(function(){
console.log('aaa='+new Date());
ii++;
if(ii==3){
clearInterval(this);
done(null,{one:"one"});
}
},1000);
},
two: function(done){
jj=0;
setInterval(function(){
console.log('bbb='+new Date());
jj++;
if(jj>3){
clearInterval(this);
done(null,{two:"two"});
}
},1000);
}
},
function(err,rs) {
console.log(err);
console.log(rs);
});
}
exec(); 2.并行无关联：async.parallel(tasks,callback);
多个函数并行执行，最后汇总结果,如果某一个流程出错就退出
async.parallel({
one: function(callback){
callback(null, 1);
},
two: function(callback){
callback(null, 2);
}
},function(err, results) {
console.log(results);
});
3.串行有关联:waterfall
每一步执行时需要由上一步执行的结果当做参数.所以每一步必须串行等待
async.waterfall([
function (done) { done(null, 'one');
},
function (onearg, done) { done(null, onearg + '| two');
},
function (twoarg, done) { done(null, twoarg + '| three');
},
function (threearg, done) { done(null, threearg + '| four');
}
], function (error, result) {
console.log(result);
console.timeEnd('waterfall');
})
例子：
function exec(){
async.waterfall(
[
function(done){
ii=0;
setInterval(function(){
console.log("aaa="+new Date());
ii++;
if(ii==3){
clearInterval(this);
done(null,'one完毕');
}
},1000);
},
function(preValue,done){
jj=0;
setInterval(function(){
console.log(preValue+"="+new Date());
jj++;
if(jj==3){
clearInterval(this);
done(null,preValue+',two完毕');
}
},1000); }
],function(err,rs){
console.log(err);
console.log(rs);
}
)
} 4.parallelLimit(tasks, limit, [callback]) parallelLimit函数和parallel类似，但是它多了一个参数limit。
limit参数限制任务只能同时并发一定数量，而不是无限制并发, async.parallelLimit([
function(callback){
callback(null, 'one');
},
function(callback){
callback(null, 'two');
}
],
2, //只允许同时有两个函数并行
function(err, results){
console.log(results);
});
我们写的js代码就像是有一个国王（主线程），而nodejs给国王提供了很多"仆人"。早上，一个仆人叫醒了国王，问他有什么需要。 国王给他一份清单，上面列举了所有需要完成的任务，然后睡回笼觉去了。当国王回去睡觉之后，仆人才离开国王，拿着清单，给其它的仆人一个个布置任务。 仆人们各自忙各自的去了（异步执行），直到完成了自己的任务后，才回来把结果禀告给国王。国王一次只召见一个人（主线程开始执行），其它的人就在外面排着队等着。国王处理完这个结果后，可能给他布置一个新的任务，或者就直接让他走了，然后再召见下一个人。等所有的结果都处理完了，国王就继续睡觉去了。直接有新的仆人完成任务后过来找他。 这就是国王的幸福生活。