【深入浅出Node.js系列十四】Nodejs异步流程控制Async

最新推荐文章于 2024-09-12 11:47:05 发布
最新推荐文章于 2024-09-12 11:47:05 发布
阅读量2.5k 收藏 4
点赞数
分类专栏： Node.js

“流程控制”本来是件比较简单的事，但是由于Nodejs的异步架构的实现方法，对于需要同步的业务逻辑，实现起来就比较麻烦。嵌套3-4层，代码就会变得的支离破碎了！今天就遇到了一个业务逻辑，连续对数据库操作，前后有依赖。让我们看看Async是如何解决问题的。

1 Async介绍

Async是一个流程控制工具包，提供了直接而强大的异步功能。基于Javascript为Node.js设计，同时也可以直接在浏览器中使用。

Async提供了大约20个函数，包括常用的 map, reduce, filter, forEach 等，异步流程控制模式包括，串行(series)，并行(parallel)，瀑布(waterfall)等。

项目地址：https://github.com/caolan/async

2 Async安装

安装async有两个方式:

  1. 独立安装async

  2. 下载async demo代码安装

2.1 独立安装async

~ D:\workspace\javascript>mkdir nodejs-async && cd nodejs-async
~ D:\workspace\javascript\nodejs-async>npm install async
npm http GET https://registry.npmjs.org/async
npm http 304 https://registry.npmjs.org/async
async@0.2.9 node_modules\async

打开网页,参照示例学习：https://github.com/bsspirit/async_demo

2.2 下载async demo代码安装

~ D:\workspace\javascript>git clone git@github.com:bsspirit/async_demo.git nodejs-async
~ D:\workspace\javascript>cd nodejs-async
~ D:\workspace\javascript\nodejs-async>npm install
npm http GET https://registry.npmjs.org/moment
npm http GET https://registry.npmjs.org/async
npm http 304 https://registry.npmjs.org/moment
npm http 304 https://registry.npmjs.org/async
async@0.2.9 node_modules\async
moment@2.1.0 node_modules\moment
`

这套demo示例，比较全面的介绍了async的使用，有中文注释。

3 Async函数介绍

基于async的0.2.9版本。async主要实现了三个部分的流程控制功能：

集合: Collections

流程控制: Control Flow

工具类: Utils

3.1 集合: Collections

each: 如果想对同一个集合中的所有元素都执行同一个异步操作。

map: 对集合中的每一个元素，执行某个异步操作，得到结果。所有的结果将汇总到最终的callback里。与each的区别是，each只关心操作不管最后的值，而map关心的最后产生的值。

filter: 使用异步操作对集合中的元素进行筛选, 需要注意的是，iterator的callback只有一个参数，只能接收true或false。

reject: reject跟filter正好相反，当测试为true时则抛弃

reduce: 可以让我们给定一个初始值，用它与集合中的每一个元素做运算，最后得到一个值。reduce从左向右来遍历元素，如果想从右向左，可使用reduceRight。

detect: 用于取得集合中满足条件的第一个元素。

sortBy: 对集合内的元素进行排序，依据每个元素进行某异步操作后产生的值，从小到大排序。

some: 当集合中是否有至少一个元素满足条件时，最终callback得到的值为true，否则为false.

every: 如果集合里每一个元素都满足条件，则传给最终回调的result为true，否则为false

concat: 将多个异步操作的结果合并为一个数组。

3.2 流程控制: Control Flow

series: 串行执行，一个函数数组中的每个函数，每一个函数执行完成之后才能执行下一个函数。

parallel: 并行执行多个函数，每个函数都是立即执行，不需要等待其它函数先执行。传给最终callback的数组中的数据按照tasks中声明的顺序，而不是执行完成的顺序。

whilst: 相当于while，但其中的异步调用将在完成后才会进行下一次循环。

doWhilst: 相当于do…while, doWhilst交换了fn,test的参数位置，先执行一次循环，再做test判断。

until: until与whilst正好相反，当test为false时循环，与true时跳出。其它特性一致。

doUntil: doUntil与doWhilst正好相反，当test为false时循环，与true时跳出。其它特性一致。

forever: 无论条件循环执行，如果不出错，callback永远不被执行。

waterfall: 按顺序依次执行一组函数。每个函数产生的值，都将传给下一个。

compose: 创建一个包括一组异步函数的函数集合，每个函数会消费上一次函数的返回值。把f(),g(),h()异步函数，组合成f(g(h()))的形式，通过callback得到返回值。

applyEach: 实现给一数组中每个函数传相同参数，通过callback返回。如果只传第一个参数，将返回一个函数对象，我可以传参调用。

queue: 是一个串行的消息队列，通过限制了worker数量，不再一次性全部执行。当worker数量不够用时，新加入的任务将会排队等候，直到有新的worker可用。

cargo: 一个串行的消息队列，类似于queue，通过限制了worker数量，不再一次性全部执行。不同之处在于，cargo每次会加载满额的任务做为任务单元，只有任务单元中全部执行完成后，才会加载新的任务单元。

auto: 用来处理有依赖关系的多个任务的执行。

iterator: 将一组函数包装成为一个iterator，初次调用此iterator时，会执行定义中的第一个函数并返回第二个函数以供调用。

apply: 可以让我们给一个函数预绑定多个参数并生成一个可直接调用的新函数，简化代码。

nextTick: 与nodejs的nextTick一样，再最后调用函数。

times: 异步运行,times可以指定调用几次，并把结果合并到数组中返回。

timesSeries: 与time类似，唯一不同的是同步执行。

3.3 工具类: Utils

memoize: 让某一个函数在内存中缓存它的计算结果。对于相同的参数，只计算一次，下次就直接拿到之前算好的结果。

unmemoize: 让已经被缓存的函数，返回不缓存的函数引用。

log: 执行某异步函数，并记录它的返回值，日志输出。

dir: 与log类似，不同之处在于，会调用浏览器的console.dir()函数，显示为DOM视图。

noConflict: 如果之前已经在全局域中定义了async变量，当导入本async.js时，会先把之前的async变量保存起来，然后覆盖它。仅仅用于浏览器端，在nodejs中没用，这里无法演示。

async_demo使用介绍，详细使用请参考github源代码：https://github.com/bsspirit/async_demo每个函数的用法，有非常详细的实例！！

4 场景：对数据库的连续操作

原场景中，对数据串行操作，增删改查(CRUD)，代码如下：

var mysql = require('mysql');
var conn = mysql.createConnection({
    host: 'localhost',
    user: 'nodejs',
    password: 'nodejs',
    database: 'nodejs',
    port: 3306
});
conn.connect();

var insertSQL = 'insert into t_user(name) values("conan"),("fens.me")';
var selectSQL = 'select * from t_user limit 10';
var deleteSQL = 'delete from t_user';
var updateSQL = 'update t_user set name="conan update"  where name="conan"';

//delete
conn.query(deleteSQL, function (err0, res0) {
    if (err0) console.log(err0);
    console.log("DELETE Return ==> ");
    console.log(res0);

    //insert
    conn.query(insertSQL, function (err1, res1) {
        if (err1) console.log(err1);
        console.log("INSERT Return ==> ");
        console.log(res1);

        //query
        conn.query(selectSQL, function (err2, rows) {
            if (err2) console.log(err2);

            console.log("SELECT ==> ");
            for (var i in rows) {
                console.log(rows[i]);
            }

            //update
            conn.query(updateSQL, function (err3, res3) {
                if (err3) console.log(err3);
                console.log("UPDATE Return ==> ");
                console.log(res3);

                //query
                conn.query(selectSQL, function (err4, rows2) {
                    if (err4) console.log(err4);

                    console.log("SELECT ==> ");
                    for (var i in rows2) {
                        console.log(rows2[i]);
                    }
                });
            });
        });
    });
});

//conn.end();

为了实现了串行操作，所有的调用都是在callback中实现的，5层嵌套结构。这种代码已经变得不可以维护了。所以，需要用async库，对上面的代码结构进行重写！

var mysql = require('mysql');
var async = require('async');

var conn = mysql.createConnection({
    host: 'localhost',
    user: 'nodejs',
    password: 'nodejs',
    database: 'nodejs',
    port: 3306
});

var sqls = {
    'insertSQL': 'insert into t_user(name) values("conan"),("fens.me")',
    'selectSQL': 'select * from t_user limit 10',
    'deleteSQL': 'delete from t_user',
    'updateSQL': 'update t_user set name="conan update"  where name="conan"'
};

var tasks = ['deleteSQL', 'insertSQL', 'selectSQL', 'updateSQL', 'selectSQL'];
async.eachSeries(tasks, function (item, callback) {
    console.log(item + " ==> " + sqls[item]);
    conn.query(sqls[item], function (err, res) {
        console.log(res);
        callback(err, res);
    });
}, function (err) {
    console.log("err: " + err);
});

控制台输出：

deleteSQL ==> delete from t_user
{ fieldCount: 0,
  affectedRows: 0,
  insertId: 0,
  serverStatus: 34,
  warningCount: 0,
  message: '',
  protocol41: true,
  changedRows: 0 }
insertSQL ==> insert into t_user(name) values("conan"),("fens.me")
{ fieldCount: 0,
  affectedRows: 2,
  insertId: 45,
  serverStatus: 2,
  warningCount: 0,
  message: '&Records: 2  Duplicates: 0  Warnings: 0',
  protocol41: true,
  changedRows: 0 }
selectSQL ==> select * from t_user limit 10
[ { id: 45,
    name: 'conan',
    create_date: Fri Sep 13 2013 12:24:51 GMT+0800 (中国标准时间) },
  { id: 46,
    name: 'fens.me',
    create_date: Fri Sep 13 2013 12:24:51 GMT+0800 (中国标准时间) } ]
updateSQL ==> update t_user set name="conan update"  where name="conan"
{ fieldCount: 0,
  affectedRows: 1,
  insertId: 0,
  serverStatus: 2,
  warningCount: 0,
  message: '(Rows matched: 1  Changed: 1  Warnings: 0',
  protocol41: true,
  changedRows: 1 }
selectSQL ==> select * from t_user limit 10
[ { id: 45,
    name: 'conan update',
    create_date: Fri Sep 13 2013 12:24:51 GMT+0800 (中国标准时间) },
  { id: 46,
    name: 'fens.me',
    create_date: Fri Sep 13 2013 12:24:51 GMT+0800 (中国标准时间) } ]
err: null

代码一下读性就增强了许多倍，这就是高效的开发。

5 Async多任务时间管理

做服务器端开发时，经常会遇到时间管理的功能需求，比如每2秒刷新一次，每三分钟做一次统计计算，周一至周五9点30启动一个定时任务等等。很多时候我们会把这些定时任务，交给linux系统的Crontab来实现。不过，有时为了增加系统的灵活性，我们需要在服务器后台实现。

对于单线程的Nodejs，如何控制多任务的时间管理呢？

5.1 需求描述

基于Nodejs的express3构建的web框架，需要在周一至周五，早上9点15分时，分别启动程序A和程序B，程序C。下午16点程序A,B,C停止。

程序A: 每1秒去redis取数据一次，保留在Nodejs的全局变量G中。

程序B: 每10秒去mysql取数据一次，通过websocket直接访问给客户端。

程序C: 每5秒对全局变量G，进行平均值计算，然后通过websocket直接访问给客户端。

5.2 Nodejs的实现方案setInterval

初始化项目：

~ cd D:\workspace\javascript\nodejs-async\demo
~ express -e timers
~ cd timers && npm install
~ npm install moment
~ npm install twix

编辑文件：app.js，在文件最面下增加新代码

...

//moment,twix时间工具
var  moment = require('moment')
    ,twix = require('twix');

//判断程序启动时间
function isTime(){
    var hms = 'HHmmss';
    return moment("091500",hms).twix(moment("160000",hms)).contains(moment());
}

//打印日志
if(isTime()){
    console.log("===============Working time===================");
}

//日志时间格式化
function now() {
    return moment().format("HH:mm:ss");
}

//全局变量G
var G = 0;

//模拟程序A
function A() {
    console.log(now() + " A(s1)=> {G:" + (G++) + "} Cache G");
}

//模拟程序B
function B() {
    console.log(now() + " B(s10)=> {B:10} TO client");
}

//模拟程序C
function C() {
    console.log(now() + " C(s5)=> {G:" + (G / 5) + "} TO client");
    G = 0;
}

//分别对A,B,C程序进行时间管理
setInterval(function () {
    if(isTime()){
        A()
    };
}, 1000);

setInterval(function () {
    if(isTime()){
        C();
    }
}, 5 * 1000);

setInterval(function () {
    if(isTime()) {
        B();
    }
}, 10 * 1000);

运行nodejs，查看日志输出：

D:\workspace\javascript\nodejs-async\demo\timers>node app.js
===============Working time===================
Express server listening on port 3000
15:02:24 A(s1)=> {G:0} Cache G
15:02:25 A(s1)=> {G:1} Cache G
15:02:26 A(s1)=> {G:2} Cache G
15:02:27 A(s1)=> {G:3} Cache G
15:02:28 A(s1)=> {G:4} Cache G
15:02:28 C(s5)=> {G:1} TO client
15:02:29 A(s1)=> {G:0} Cache G
15:02:30 A(s1)=> {G:1} Cache G
15:02:31 A(s1)=> {G:2} Cache G
15:02:32 A(s1)=> {G:3} Cache G
15:02:33 A(s1)=> {G:4} Cache G
15:02:33 C(s5)=> {G:1} TO client
15:02:33 B(s10)=> {B:10} TO client
15:02:34 A(s1)=> {G:0} Cache G
15:02:35 A(s1)=> {G:1} Cache G
15:02:36 A(s1)=> {G:2} Cache G
15:02:37 A(s1)=> {G:3} Cache G
15:02:38 A(s1)=> {G:4} Cache G
15:02:38 C(s5)=> {G:1} TO client
15:02:39 A(s1)=> {G:0} Cache G
15:02:40 A(s1)=> {G:1} Cache G
15:02:41 A(s1)=> {G:2} Cache G
15:02:42 A(s1)=> {G:3} Cache G

程序A,每1秒运行一次，给G+1。

程序B,每10秒运行一次，输出到客户端。

程序C,每5秒运行一次，取G的平均值，给G赋值为0，输出到客户端。

虽然完成了功能需求，但是代码不美观！如果再增加任务D,E,F….代码不好维护。

5.3 Async多任务时间管理

下面我们用async包，对上面的浏览进行封装。

//moment,twix时间工具
var  moment = require('moment')
    ,twix = require('twix');

//判断程序启动时间
function isTime(){
    var hms = 'HHmmss';
    return moment("091500",hms).twix(moment("160000",hms)).contains(moment());
}

//打印日志
if(isTime()){
    console.log("===============Working time===================");
}

//日志时间格式化
function now() {
    return moment().format("HH:mm:ss");
}

//全局变量G
var G = 0;

//模拟程序A
function A() {
    console.log(now() + " A(s1)=> {G:" + (G++) + "} Cache G");
}

//模拟程序B
function B() {
    console.log(now() + " B(s10)=> {B:10} TO client");
}

//模拟程序C
function C() {
    console.log(now() + " C(s5)=> {G:" + (G / 5) + "} TO client");
    G = 0;
}

var async = require('async');

var arr = [
    {fun: A, delay: 1000, test: isTime},
    {fun: B, delay: 10 * 1000, test: isTime},
    {fun: C, delay: 5 * 1000, test: isTime}
];

async.each(arr, function (item, callback) {
    async.whilst(item.test,function(cb) {
            item.fun();
            setTimeout(cb, item.delay);
        },function(err) {
            console.log("Not working time!");
        }
    );
}, function (err) {
    log('Error: ' + err);
});

构建一个arr数组，封装调用的A,B,C的参数。

使用async.each函数，对arr的item异步并行

使用async.whilst函数，对任务启动时间进行判断，并根据delay运行任务

程序运行结果与setInterval一样。而代码更利于维护，一旦需要增减任务，简单地修改arr的数组就行了，其他的代码都不用动！！

清觞煮雪
关注
专栏目录
Nodejs中的异步编程类库Async
win0032的博客
05-21 476
今天在用mongodb和express中做博客时,教程中提到了对于mongodb的操作及回调的过程是典型的深度嵌套回调,代码如下Post.getOne = function(name, day, title, callback) { mongodb.open(function (err, db) { if (err) { ... } db.collection('posts'
Nodejs让异步变成同步的方法
10-17
今天小编就为大家分享一篇关于Nodejs让异步变成同步的方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Nodejs异步流程控制Async
fens的博客
09-13 372
从零开始nodejs系列文章，将介绍如何利Javascript做为服务端脚本，通过Nodejs框架web开发。Nodejs框架是基于V8的引擎，是目前速度最快的Javascript引擎。chrome浏览器就基于V8，同时打开20-30个网页都很流畅。Nodejs标准的web开发框架Express，可以帮助我们迅速建立web站点，比起PHP的...
nodejs基础教程之-异步编程promise/async/generator
最新发布
峰会路转的博客
09-12 1235
所谓"异步"，简单说就是一个任务分成两段，先执行第一段，然后转而执行其他任务，等做好了准备，再回过头执行第二段,比如，有一个任务是读取文件进行处理，异步的执行过程就是下面这样。当你在执行一个函数的时候，你可以在某个点暂停函数的执行，并且做一些其他工作，然后再返回这个函数继续执行， 甚至是携带一些新的值，然后继续执行。当你在执行一个函数的时候，你可以在某个点暂停函数的执行，并且做一些其他工作，然后再返回这个函数继续执行， 甚至是携带一些新的值，然后继续执行。相应地，连续的执行，就叫做同步。
nodejs异步流程控制
这天有点热的博客
11-06 211
var async = require('async'); function oneFun(){ console.log('oneFun'); /* setTimeout(function(){ },1000); */ i = 0; setInterval(function(){ console.log('aaaaaa'+new Date()); i++; if...
Nodejs 异步流程控制（下）
凯歌技术控团队
12-02 271
【代码】Nodejs 异步流程控制（下）
Node.js系列--异步流程控制
Closure 专栏
01-12 1541
异步编程是Node.js中最大的特点，在Node.js的编程实践中我们为了使得其发挥特性，将所有的东西都写成异步方式，特别是异步回调方式。在Node.js原生代码中，只有fs模块即提供了同步版本又提供了异步版本。现在我们来认识一下Node.js的异步流程控制。 一、 callback 在Node.js中，无论是自定义API还是原生方法到处都可以看到callback的身影，说道callback就
深入浅出nodejs.pdf
09-15
本书《深入浅出Node.js》从多个角度细致深入地探讨了Node.js的内部工作机制和应用实践。 首先，Node.js的核心优势之一是其异步I/O模型。传统的Web应用模型中，对于I/O操作（如读写数据库、文件系统和网络请求等），...
浅谈node.js中async异步编程
10-23
Node.js是一种采用Chrome...总结来说，异步编程是Node.js开发中的一个重要概念，async库的出现极大地简化了异步流程的控制。通过上述知识点，初学者可以更好地理解和掌握Node.js中的异步编程，并在实际开发中加以应用。
Nodejs异步流程框架async的方法
01-02
基于Javascript为Node.js设计，同时也可以直接在浏览器中使用。Async提供了大约20个函数，包括常用的map, reduce, filter, forEach等，异步流程控制模式包括，串行(series)，并行(parallel)，瀑布(waterfall)等。 ...
Nodejs 异步流程控制（上）
凯歌技术控团队
12-02 424
【代码】Nodejs 异步流程控制（上）
nodejs中Async库介绍
chouyu3076的博客
02-16 106
Async 地址：https://github.com/caolan/async Async的内容分为三部分： 流程控制：简化十种常见流程的处理 集合处理：如何使用异步操作处理集合中的数据 工具类：个常用的工具类 本文介绍其中最简单最常用的流程控制部分。 由于no...
node.js异步转同步 fibers模块
fjs的专栏
04-21 7866
javascript最大的一个特点就是单线程，但是可以同时挂起多个执行链，同时javascript能够很简单的实现回调函数，这些都十分满足异步编程的要求，这些特点最终也成为了node.js的十分重要的属性，这十分符合非阻塞编程的模型的要求，从而也使得node.js具备了十分优秀的处理并发的能力。。。即使不用c语言，不用涉及epoll等也可以实现很好的并发性能。（当然在内存和cpu等方面还是具有很大
简单的node爬虫练手，循环中的异步转同步
小六子不伶俐
09-05 1770
看到网上一些基于node做的爬虫项目，自己也想写一下练手 一、开发环境搭建  1. node 安装最新版 后面会用到async、await   2. webstrom编辑器  3. 新建reptitle文件夹 --> npm init (初始化工程) 二、爬取页面分析 三、关键代码 1. 代码分析   cheerio包用于解析页面中的html,用法同
nodejs异步转同步
whiteGay的博客
10-10 529
项目在微信环境开发，需要获取access_token进行授权登录和获取用户信息。 特意把这块功能拿出来封装一个自定义module module.exports = new Wechat(con.app...
关于Node.js异步转同步
weixin_30339457的博客
08-06 91
　　用Node.js做开发我们有时候会很沉浸在它的异步回调机制中。发送一个请求，不管什么时候响应，我们写好一个对应的回调函数（callback），然后我们就可以进行下一步的操作。但是有时候我们又会陷入苦恼之中，比如说我必须在取得回调之后的数据之后才能进行接下来的操作，那么我们就要想办法转异步为同步了。 最常见的异步操作： Async(parameters,function(){ 　　//回调...
node 多个异步方法转同步
枯叶的博客
02-02 547
node 多个异步方法转同步 异步转同步的方式有很多种，但是在实际开发中，有些场景还是需要选择使用最适合的方式去处理，这里就提供一种。 场景： 我想要多个异步任务按顺序的执行（种种元素不能用 await） 有以下 a ，b , c 三个异步方法 const a = () =>{ return new Promise((resolve,reject)=>{ setTimeout(()=>{ resolve('------a-----') },3000) }
node同步异步
buzaisonghua的博客
05-21 469
在node中经常会遇到关于同步与异步 编译语言按各种方法可以分为各种类型，语言分为编译性语言和解释性语言 编译性语言的定义，编译性语言编写的程序被执行前，需要一个专门的编译过程，在运行前编译成机器语言文件， C++,编译后生成exe文件，无需再次编译，直接运行就可以了 但是Java、scala 则是先编译成字节码，然后解释执行字节码（可以理解为编译型语言也可以理解为解释型语言）。准确的理解，jav...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值