前端点滴（Node.js）（三）异步I/O、异步编程 ----重点

Node.js

一、异步 I/O

1. 异步I/O的概念

当一个异步过程调用出发后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态，通知和回调来通知调用者。

接下来先来回顾一下Ajax异步请求：

/* javascript Ajax 请求 */
var xhr = new XMLHttpRequest();
xhr.open('get','xxx.php',true);
xhr.send();
xhr.onreadystatechange = funtion(){
    console.log('收到响应');
}
console.log('发送Ajax请求结束');

/* jQuery Ajax 请求 */
$.post('xxx.php',function(data){
    console.log('收到响应');
})
console.log('发送Ajax请求结束');

熟悉异步请求的用户都知道，'收到响应’是在’发送Ajax请求结束’之后输出的。在发送请求后，后续代码时会被立即执行的，而’收到响应’的执行时间是不被预期的。我们只知道它将会在这个异步请求结束后执行，但并不知道具体的时间，只能通过事件的监听、回调函数获取响应数据。异步调用中对结果值得捕获完全符合"Don't call me，I will call you"都原则，这也是只注重结果，不注重过程的表现。

经典的Ajax异步调用。

在Node中，异步I/O也是非常常见的，以阅读文件为例，我们可以观察到他与前端Ajax调用的方式及其类似。

var fs = require('fs');
fs.readFile('./xxx.html',function(err,data){
    console.log('读取文件完成');
})
console.log('发送读取文件');

同样"读取文件完成"的输出会晚于"发送读取文件"，同样"读取文件完成"的执行也取决于读取文件的异步调用何时结束。

经典的异步调用。

在Node中，绝大多数的操作都是以异步的方式进行调用的。

同步I/O与异步I/O，阻塞I/O与非阻塞I/O的区别：

• 同步I/O：同步就是在一个功能调用时，在没有得到结果之前，该调用就不返回。也就是一件一件事做，等前一件做完了才做下一件事。

• 异步I/O：异步和同步相对，当一个异步过程调用出发后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态，通知和回调来通知调用者。

• 阻塞I/O：就是在IO执行的两个阶段（等待数据 和拷贝数据两个阶段）数据没来，啥都不做，直到数据来了，才进行下一步的处理，CPU会等待I/O，造成等待资源浪费。

• 非阻塞I/O：实现了同时服务多个客户端，能够在等待任务完成的时间里干其他活了，包括提交其他任务。但是不停的轮询recv，占用较多的cpu资源，造成资源的浪费。
  

扩展：轮询

由于完整的I/O并没有完成，立即返回的并不是业务层期望的数据，而是仅仅表示当前调用的状态。为了获取完整的数据，应用程序需要重复调用I/O操作来确认是否完成。这种重复调用判断操作是否完成的技术叫做轮询。

https://blog.csdn.net/Errrl/article/details/103979471

2. 为什么需要异步I/O

为什么node要设计异步I/O，这与node面向网络而设计不无关系。

（1）用户体验

在《高性能JavaScript》一书中曾经总结过，如果脚本的执行时间超过100ms，用户就会感觉到页面的卡顿，以为页面停止了响应。而这其中的关键在于网络速度的限制给网页的实时体验造成很大的麻烦。如果网页临时需要获取一个网络资源，通过同步的方式获取，那么JavaScript则需要等待资源完全从服务器端获取后才能继续执行，这期间的UI将会停顿，不响应用户的交互行为。可想而知，这样的用户体验将会有多差。

可以这样理解，假如一个资源来自两个不同位置的数据返回，第一个资源需要消耗M毫秒，第二个资源需要消耗N毫秒，如果使用同步的方式总耗时就是M+N毫秒，而如果使用的是异步的方式则是 max（M,N）。

可以这么说只有后端能够快速响应资源，才能然前端的体验变好

（2）资源分配

接下来就从资源分配的角度分析node为什么要设置异步I/O。

假设业务场景中有一组互不相关的任务需要完成，现行阶段主流的方法有以下两种：

• 单线程串行顺序执行

单线程顺序执行任务的方式比较符合编程人员按顺序思考的思维方式。它依然是最主流的编程方式，因为它易于表达。但是顺序执行的缺点在于性能，任意一个略忙的任务还未执行完毕就会导致后续执行代码被阻塞。在计算机资源中，通常I/O与CPU计算之间是并行进行的。但是同步的编程模块导致的问题是，I/O的进行会让后续任务等待，这造成资源不能被更好地利用。

• 多线程并行完成

相比于单线程串行顺序执行，多线程并行完成的代价在于创建线程和执行期线程上下文切换的开销比较大，同时还会面临多线程死锁、状态同步等等的问题。

因此node在两者之间做出了自己的方案：利用单线程，远离多线程死锁、状态同步等问题；利用异步I/O，让单线程远离阻塞，以更好地利用CPU资源。

3. Node 的异步I/O实现

Node中完成整个异步I/O环节有事件循环、观察者和请求对象。

（1）事件循环

首先，着重强调一下Node自身的执行模型——事件循环，正是它使得回调函数十分普遍。

在进程启动时，Node会创建一个while循环，每执行一次循环体的过程我们称为Tick，每个Tick的过程就是查看是否有事件待处理，如果有，就取出事件以及相关的回调函数，如果存在关联的回调函数就执行，然后进入下一个循环，如果不再有事件处理，就退出进程。

（2）观察者

在每一个Tick的过程中，如何判断是否还有事件需要处理？

在这里必须引入的概念就是观察者。——IOCP相关的GetQueuedCompletionStatus()方法。

每一个事件循环中都存在一个或多个观察者，而判断是否有事件要处理的过程就是向这些观察者询问是否又要处理的事件。

（3）请求对象

对于一般的（非异步）回调函数，函数由我们自行调用，比如：

var list = [1,2,3,4];
function callback(a,b,c){
    console.log(a,b,c);
}
var forEach = function(list,callback){
    for(var i = 0;i<list.length;i++){
        callback(list[i],i,list);
    }
}
forEach(list,callback);

对于Node中的异步I/O调用而言，回调函数却不由开发者来调用。那么从我们发出调用后，到回调函数被执行，中间发生了什么？事实上，从JavaScript发起调用到内核执行完I/O操作的过渡过程中，存在一种中间产物，它就叫做请求对象。

（4）总结：完整的异步I/O流程

其中的IOCP就与I/O观察者相关。

事件循环、观察者、请求对象、I/O线程池四者共同构成了Node异步I/O模型的基本要素。

二、异步编程

有异步I/O，就必须有异步编程。异步的广泛使用使得回调、嵌套的出现。

1. 异步编程的优势与难点

（1）优势

只要合理地利用Node异步模块与V8的高性能，就可以充分发挥CPU和I/O资源的优势。

（2）难点

Node异步编程借助于异步I/O模型以及V8高性能引擎，突破单线程的性能瓶颈，让JavaScript在后端达到了实用的价值。另一方面它统一了前后端JavaScript的编程模型。接下来就来梳理一下异步编程中的难点，以更好地使用Node。

• 难点一：异常处理

在使用Node前通常使用try/catch/finally语句块进行异常的捕获。

但是对于异步编程而言并不一定适用。所以Node在处理异常上形成了一种约定，将异常作为回调函数的第一个实参传回，如果为空值，则表明没有异常抛出：

async function(err,res){
	//do something...
}

在我们自行编写的异步方法上，如果有对异常捕获的需求，也需遵循这样的一些规则：

1）必须执行调用者的回调函数；

2）正确传回异常共调用者判断；

示例如下：

var async = function(callback){
    process.nextTick(function(){
        var res = /* something */;
        if(error){
            return callback(error);
        }
        callback(null,res);
    })
}

值得注意的是：在异步编程中容易犯的错误是对用户传递的回调函数进行了异常的捕获：

/* 错误 */
try{
    req.body = JSON.parse(buf,option.reviver);
    callback();
}catch(err){
    err.body = buf;
    err.status = 400;
    callback(err);
}

上述示例中会发现一个问题，就是异常捕获的目标发生了改变，原本是想捕获JSON.parse中可能出现的问题，反而现在却是捕获回调函数的异常，同时还发现回调函数不经意间被执行了两次。因此这种情况极有可能造成业务的混乱，正确的做法是：

/* 正确 */
try{
    req.body = JSON.parse(buf,option.reviver);
}catch(err){
    err.body = buf;
    err.status = 400;
    return callback(err);
}
callback();

• 难点二：函数嵌套太深

对于Node而言，事务中存在多少个异步调用的场景比比皆是，就比如遍历目录的操作，代码如下：

var fs = require('fs');
fs.readdir('./',function(err,data){
    data.forEach(function(keys,value){
        fs.readFile(value,'utf8',function(err,res){
            //do something...
            //...
        })
    })
})

对于上述的场景，由于两次操作存在依赖，函数的嵌套情有可原。那么在网页渲染过程中，通常需要模板、数据、资源文件，这三者互相之间并不依赖，当最终渲染结果中三者缺一不可。如果采取默认的异步方法调用，程序书写会是如下：

fs.readFile('模板地址','utf8',function(err,datas){
    数据库.query('SQL语句'，function(err,data){
        资源模块.get(function(err,resources){
            //do something...
        })
    })
})

如果根据上述情况，应为嵌套深度在未来node有可能是最难看的代码，当现实情况还不是那么糟糕，接下来来看看如何解决问题。

• 难点三：阻塞代码

在php中有sleep方法（线程沉睡），但是JavaScript没有，唯独能用于延时的操作就只有setInterval和setTimeout这两个函数。如果了解这两个函数的清楚它们都是异步的，也就是说这两个函数并不能阻塞后续代码的持续执行。满足不了阻塞后置代码执行的需求，如果想要满足需求则：

var start = new Data();
while(new Data()-start<1000){
    //等待...
}
//后置代码(任务需要阻塞的代码)

看上去好像与sleep(1000)效果相同，但事实上这段代码比sleep(1000)更加可怕，这段代码会持续占有CPU进行判断，与真正的sleep(1000)线程沉睡相距甚远，完全破坏了事件循环的调度，由于Node单线程的原因，CPU资源全都用在了这段代码中，导致其与任何请求都会得不到响应。

遇到这种情况，还是建议在同一业务逻辑后，调用setTimeout()进行延时，反而效果会更好。

2. 异步编程的解决方案

（1）事件发布/订阅模式

事件监听器模式是一种广泛用于异步编程的模式，是回调函数的事件化，又被称为发布/订阅模式。

Node自身提供events模块是发布/订阅模式一个简单的实现，Node中部分模块都继承自它，这个模块不存在事件的冒泡也不存在prevent Default()、stopPropagation()和stopImmediatePropagation()等控制事件传递的方法。它具有的是addListener/on()、once()、removeListener()、removeAllListener()以及emit()等基本事件监听模式的方法实现。

简单的发布与订阅

const EventEmitter = require('events');
const myEmitter = new EventEmitter();
//const events = require('events');
//const myEmitter = new events.EventEmitter();

// 第一个监听器。订阅一
myEmitter.on('event', function firstListener() {
  console.log('第一个监听器');
});
// 第二个监听器。订阅二
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`第二个监听器中的事件有参数 ${arg1}、${arg2}`);
});
// 第三个监听器。订阅三
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`第三个监听器中的事件有参数 ${parameters}`);
});

console.log(myEmitter.listeners('event'));

/* 发布 */
myEmitter.emit('event', 1, 2, 3, 4, 5);

// 输出：
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
//
// 第一个监听器
// 第二个监听器中的事件有参数 1、2
// 第三个监听器中的事件有参数 1, 2, 3, 4, 5

1.1应用场景

1.1.1 继承events模块

/************* Node中Stream对象继承EventEmitter的例子 *************/
const util = require('util');
const EventEmitter = require('events');

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`接收的数据："${data}"`);
});
stream.write('运作良好！'); // 接收的数据："运作良好！"


/************* 使用ES6类进行继承 *************/
const EventEmitter = require('events');

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`接收的数据："${data}"`);
});
stream.write('使用 ES6');

开发者可以通过这两种方式轻松地继承EventEmitter类，利用事件处理机制解决业务。

1.1.2 利用事件队列解决雪崩问题

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

以下是一条数据库查询语句的调用：

var select = function(callback){
    数据库模块.select('SQL语句',function(res){
        callback(res);
    });
};

如果站点 刚好启动，这时缓存是不存在数据的，如果访问量过大，同一句SQL语句被发送到数据库中反复查询，会影响服务器整体的性能。

解决方案一：

/* 设置状态锁，只执行第一次数据库查询，后续的select()是没有数据服务的。 */
var status = 'ready';
var select = function(callback){
    if(status === 'ready'){
        status = 'pending';
        数据库模块.select('SQL语句',function(res){
        status = 'ready';
        callback(res);
    });
    }
}

解决方案二：

/* 引入事件队列，利用once()监听事件的方法解决雪崩 */
var events = require('events');
var proxy = new events.EventsEmitter();
var status = 'ready';
var select = function(callback){
    /* once()事件监听，订阅 */
    proxy.once('selected',res)
    if(status === 'ready'){
        status = 'pending';
         数据库模块.select('SQL语句',function(res){
        status = 'ready';
        /* 发布 */
        proxy.emit('selected',res);
    });
    }
}

这里我们使用once()的方法，将所有请求的回调都压入事件队列中，利用其仅执行一次后监视器移除的特性，保证每一次回调只执行一次。

1.1.3 利用事件发布/订阅解决方嵌套深度问题

上述难点二中的异步函数嵌套深度很有可能造成回调地狱，解决的方法就是发布/订阅，串行执行。

难点二：

fs.readFile('模板地址','utf8',function(err,datas){
    数据库.query('SQL语句'，function(err,data){
        资源模块.get(function(err,resources){
            //do something...
        })
    })
})

解决难点二

方法一：调用函数多对一收敛

/* 渲染 */
var count = 0;
var res = {};
var done = function(key,value){
    res[key] = value;
    count++;
    if(count===3){
        //渲染页面
        render(res);
    };
};

/* 串行执行 */
fs.readFile('模板地址','utf8',function(err,datas){
    done('datas',datas);
})
数据库.query('SQL语句'，function(err,data){
    done('data',data);
})
资源模块.get(function(err,resources){
    done('resources',resources);
});

（2）Promise/Deferred模式

2.1 Promise/A

Promise抽象定义：

1. 一个promise必须有3个状态，pending未完成态，fulfilled(resolved)完成态，rejected失败态。
2. 当处于pending状态的时候，可以转化为fulfilled(resolved)或者rejected状态，不可逆。当处于fulfilled(resolved)状态或者rejected状态的时候，就不能互相转化。
3. promise的状态一旦转化就不能更改。

对于then()方法的抽象定义：

1. 接受完成态、失败态的回调方法，在操作完成或失败时将会调用对应的方法。
2. then()方法只能接受function对象，其余对象将会被忽略。
3. then()方法继续返回promise对象，以实现链式调用。

node环境中手写Promise原理

JavaScript：（test.js）

1）让promise继承events每一种状态订阅一个事件；使用then存放所有的回调函数。

/* promise.js */
/* 继承events */
const util = require('util');
const eventEmitter = require('events');
var Promise = module.exports = function(){
    eventEmitter.call(this);
};
util.inherits(Promise,eventEmitter);
Promise.prototype.then = (fulfilledHandler,rejectHandler,pedingHandler)=>{
    if(typeof fulfilledHandler === 'function'){
        this.once('resolve',fulfilledHandler);
    }
    if(typeof rejectHandler === 'function'){
        this.once('reject',rejectHandler);
    }
    if(typeof pedingHandler === 'function'){
        this.once('peding',pedingHandler);
    }
    return this;
}

2）定义状态的改变的构造函数，发布事件，而这个定义状态改变的构造函数的实例对象就是Deferred。

PromiseA+与Deferred关系如下：

/* deferred.js */
/* 定义状态构造函数，发布事件 */

var Promise = require('./promise');

var Deferred = module.exports = function(){
    this.state = 'unfulfilled';
    this.promise = new Promise();
}
Deferred.prototype.resolve = function(obj){
    this.state = 'fulfilled';
    this.promise.emit('resolve',obj);
}
Deferred.prototype.reject = function(err){
    this.state = 'rejected';
    this.promise.emit('reject',err);
}
Deferred.prototype.peding = function(data){
    this.promise.emit('peding',data);
}

3）实现接口

• 作用一：触发事件的发布
• 作用二：作用就是绑定http response的res的data、end、error事件侦听器

/* test.js */
/* 定义接口，触发事件的发布 */

var Deferred = require('./deferred');
var http = require('http');

var interface = function(res){
   var deferred = new Deferred(); 
    var result = '';
    res.on('data',chunk=>{//相当于peding
        result += chunk;     
        deferred.peding(chunk);
    });
    res.on('end',()=>{//相当于resolved
        deferred.resolve(result);
    });
    res.on('err',(err)=>{//相当于rejected   
        deferred.reject(err);
    });
    /* 使得触发后能够.then */
    return deferred.promise; 
}

4）测试

/* test.js */
// 以http调用为例
var options = {
    hostname: "www.baidu.com",
    method: "GET"
};
var req = http.request(options, function(res){
    res.setEncoding('utf8');
    promisify(res).then(function () {
        console.log("end");
    }, function(err) {
        console.log("error:", err);
    }, function (chunk) {
        console.log("Received %s bytes", chunk.length);
    });
});
/* 输出结果 */
req.end();

5）执行

拿node中读取文件为例,读取一个文件，经过Promsie/Deferred封装后，会变成如下形式：

修改接口：

/* test.js */
/* 定义接口，触发事件的发布 */
var fs = require('fs');
var Deferred = require('./deferred');

/* 读文件 */
var interface = function(path){
    var deferred = new Deferred(); 
   	fs.readFile(path,'utf8',(err,data)=>{
   		if(err){
   			deferred.reject(err);
   		}
   		deferred.resolve(data);
    })
    return deferred.promise;
}
/* 写文件 */
var interface2 = function (path, content) {
    var deferred = new Deferred();
    fs.writeFile(path, content, 'utf8', (err, data) => {
        if (err) {
            deferred.reject(err);
        }
        deferred.resolve(data);
    })
    return deferred.promise;
}

测试：

/* test.js */
/* 读取文件，写文件 */
interface("./test.txt")
.then((data) => {
    console.log(data);
}, (err) => {
    console.log(err);
})
.then(
interface("./test2.txt")
.then((data) => {
interface2('./test3.txt', data)
.then(() => {
console.log('写入成功');
}, (err) => {
console.log(err);
})
}, (err) => {
console.log(err);
}))

结果：

2.2 使用q：npm install q

给方法定义一个 promise 规范：修改接口：test.js

Q.defer:

手动封装一个promise

特点：使用deferd对象的reject方法（失败回调）、resolve方法（成功回调）、promise属性来实现自定义promise。（前面2个nfcal、denodeify底层应该也是用deferd实现的）

var fs = require('fs');
var Q = require('q');
/* 读文件 */
var interface = function(file){
   var defer = Q.defer();
   fs.readFile(file, "utf8",function(err,data){            
       if(!err){
           defer.resolve(data);//成功就返回数据
       }else{
           defer.reject(err);//失败就返回错误
       }           
   });
   return defer.promise;//必须返回promise
}
/* 写文件 */
var interface2 = function (path, content) {
    var defer = Q.defer();
    fs.writeFile(path, content, 'utf8', (err, data) => {
        if(!err){
           defer.resolve(data);//成功就返回数据
       	}else{
           defer.reject(err);//失败就返回错误
       	} 
    })
    return defer.promise;
}

Q.all

将一批promise封装成一个promise

特点：可以并行执行一批promise，全部执行完毕后一起返回，得到的结果是一个数组

Q.all([//执行多个函数
    interface("./test.txt"),
    interface("./test2.txt"),
    interface2('./test3.txt','写入成功')
])
.spread(function (rtn1,rtn2,rtn3) {
    //对应的多个返回值
    console.log(rtn1,rtn2,rtn3);
    return rtn1+rtn2+rtn3;
})
.done(function(result){
    console.log(result);
});

以及一些常用方法：

• Q.makeNodeResolver:

手动封装一个promise

特点：和第deferd原理差不多，只不过用了deferd自带的方法省掉了我们手动实现reject方法、resolve方法

示例：

var readfile_d=function(filename){
   	var defer=Q.defer();
  	fs.readFile(filename,"utf8",defer.makeNodeResolver());
	return defer.promise;
}

readfile_d(filename).then(...);

• Q

将数据封装成promise

特点：封装一个数据，调用then直接得到该数据

示例：

Q('hello world').then(data=>{
    console.log(data);
})
//=> hello world

• Q.fcall

将同步方法封装成promise

特点：传递一个function，返回一个promise，调用then得到方法的返回值

示例：

Q.fcall(function(){
    return interface('test.txt');
})
.then(function(data1){
    return interface('test2.txt');
})
.then(function(data2){
    return interface2('test3.txt',data2);
})
.catch(function (error) {
    
})
.done(function(res){
    console.log(res);
});
//=> undefined

• Q.nfcall:

将异步方法封装成promise

特点：封闭时就得传递调用方法的参数，直接得到promise

示例：

Q.nfcall(fun,p1,p2).then(...);

• Q.denodeify:

将异步方法封装成promise

特点：封装后返回一个方法，调用此方法得到promise

示例：

var dd = Q.denodeify(fun);
dd(p1,p2).then(...);

（3）流程库控制（Generator/async/await函数）

3.1 Generator函数（function*）与异步

/* 封装一个promise函数 */
const readFile = path => {
    const promise = new Promise((resolve, reject) => {
        fs.readFile(path,(err,data) => {
            if(err) {
                reject(err);
                return;
            }
            resolve(data);
            return;
        })
    })
    return promise;
}
/* Generator生成器函数 */
const readFileGenerator = function* (path) {
    const data1 = yield readFile(path);
    const data2 = yield readFile(data1.toString());
    console.log(data1.toString());
    console.log(data2.toString());
}
 
// 使用
const test1 = readFileGenerator('./test5.txt');
let readPromise = test1.next(); //启动Generator
readPromise.value.then(data => {
    const readPromise = test1.next(data);
    readPromise.value.then(data2 => {
      test1.next(data2)
    });
})
// ./test5.txt文件的内容为：./test6.txt
// ./test6.txt文件的内容为：我是test6文件
// 打印结果：
// './test6.txt'
// '我是test6文件'

3.2 async/await与异步

执行流程：

1. 为一个函数声明async关键字，告诉js引擎这个函数是一个async函数，也就是需要进行异步处理的一个函数。

2. async函数内部可以使用await关键字来暂停代码的执行（类似Generator的yield关键字）

3. await后面跟随的是一个promise对象，然后async会等待await后面的那个promise状态变为resolve时，代码会继续往下执行，并且其promsie的返回值就是await关键字的返回值。

4. 每碰到一个await，就会暂停一次，直到async函数执行完返回。

注意：

1. async返回的是一个promise对象，也就是说，你可以在await后面跟随另外一个async函数或者promise函数

2. async返回的promise对象p1，如果async函数内部，抛出了异常，并且没有捕获，那么异常不会被抛出到async函数之外，而是被p1这个promise对象给捕获，导致p1的状态变为reject。

3. async的返回值，会被他返回的p1这个promise对象使用，如果是返回原始类型，则用于p1的resolve方法的data，如果是抛出异常，则用于p1的reject方法的data。

4. await也可以跟随原始类型，那么此时就等同于同步操作。

5. 只要一个await语句后面的 Promise 变为reject，那么整个async函数都会中断执行（我猜测类似于使用了Generator函数的迭代器的throw方法抛出了异常）。如果想继续执行，你可以使用try…catch来包裹代码，进行异常捕获。

6. 如果await后面跟的promise已经是处于resolve或者reject，那么他会根据promise的状态进行直接返回或者抛出异常（应该是下一次nextTick或者是类似setTimeout(() => {}, 0)的执行）。

实例：

const readFile = (path) => {
    const promise = new Promise((resolve, reject) => {
        fs.readFile(path, (err, data) => {
            if (err) {
                reject(err);
                return;
            }
            resolve(data);
        });
    });
 
    return promise;
};
 
 
async function asy() {
    const res1 = await readFile('./test5.txt'); 
    const res2 = await readFile('./test6.txt'); 
    console.log(res1);
    console.log(res2);
}
 
asy();
// 打印结果：
// './test6.txt'
// '我是test6文件'

上述例子其实还不符合异步要求， 第一个readFile(’./test5.txt’)会阻塞第二个readFile(’./test6.txt’)的异步加载，因为await会等待readFile(’./test5.txt’)返回后才执行下面的代码。 由于await后面接受的是一个promise，所以，我们可以使用promise的all方法或者race来组合多个promise异步为一个promise，或者也可以这样修改：

async function asy() {
    const promise1 = readFile('./test5.txt');
    const promise2 = readFile('./test6.txt');

    const result1 = await promise1;
    const result2 = await promise2;
    console.log(result1);
    console.log(result2);
}
asy();

为了解决回调地狱问题：
比如：

setp1(function(res)){
   setp2(function(res)){
       setp3(function(res){
           setp4(function(res){
               setp5(function(res){
                   //终于执行完了
               });
           });
       });
   });
});

解决方法：异步串行执行

var async = require('async')
async.series([
    function(callback){
        fs.readFile('./test5.txt','utf8',callback);
    },
    function(callback){
        fs.readFile('./test6.txt','utf8',callback);
    }
],function(err,res){
    console.log(res);
})

• 异步并行执行parallel()方法

var async = require('async')
async.parallel([
    function(callback){
        fs.readFile('./test5.txt','utf8',callback);
    },
    function(callback){
        fs.readFile('./test6.txt','utf8',callback);
    }
],function(err,res){
    console.log(res);
})

• 异步调用的依赖处理waterfall()方法

依赖：前一个结果是后一个调用的输入参数。

//./test1.txt文件内容：./test2.txt
//./test2.txt文件内容：./test3.txt
//./test3.txt文件内容：./test4.txt

var async = require('async')
async.waterfall([
    function(callback){
        fs.readFile('./test1.txt','utf8',function(err,content){
            callback(err,content);
        });
    },
    function(arg1,callback){
        fs.readFile(arg1,'utf8',function(err,content){
            callback(err,content);
        });
    },
    function(arg1,callback){
        fs.readFile(arg1,'utf8',function(err,content){
            callback(err,content);
        });
    }
],function(err,res){
    console.log(res);
})

三、总结

异步编程到这里就告一段落了，从开始了解异步I/O引出异步编程。从我们最开始使用的回调函数，再到我们理解事件的发布/订阅模块，再然后的promise/Deferred、q，以及最后的Generator函数和async/await，他们都是在不同时期为了解决异步编程而提出的解决方案，而我们也在探索中，也逐渐完善js异步编程的体验，从最开始的回调地狱，到promise的链式处理，再到后来的Generator函数和async/await可以让我们以同步的方式书写异步代码 ，希望本文能带给你一些知识的积累。