异步编程

JavaScript

Node 的异步机制

事件循环

进程启动时，Node 就会创建一个循环，每执行一次循环体的过程称为 Tick。

线程池

观察者的回调函数来自于线程池。每次 Tick 的执行过程中，它都会检查线程池中是否有执行完的请求，如果存在，就会将请求对象加入到观察者的队列中。

在调用的时候请求对象的 result 属性作为参数，oncomplete_sym 属性作为方法。

异步调用

当发起异步调用的时候，底层首先创建一个请求对象，然后将 JavaScript 层中传入的参数和方法封装在请求对象的 result 属性和 oncompelet_sym 属性中。然后将这个对象推入到线程池中等待执行。

非 I/O 的异步 API

• setTimeOut
• setInterval
• process.nextTick: 接受一个回调函数，在下一个 Tick 中执行这个回调函数。
• setImmediate: setImmediate 与 process.nextTick 不同的地方在于，前者将结果保存在链表中，在每一个 Tick 中只会执行一个回调函数；后者将结果保存在数组中，会在下一个 Tick 中执行全部回调函数。

另外：process.nextTick 属于 idle 观察者，setImmediate 属于 cheek 观察者，idle 观察者先于 cheek 观察者。

事件发布/订阅模式

可以通过继承 events 模块来利用事件机制解决业务问题。
API

// 订阅
emitter.on('event1', function(e) {
    console.log(e);
});
// 发布
emitter.emit('event1', 'I am message');

实现

var events = require('events');
var util = require('util');
function Emitter() {
    events.EventEmitter.call(this);
}
util.inherits(Emitter, events.EventEmitter);
var emitter = new Emitter();

Promise/Deferred 模式

API
then(fulfilledHandler, errorHandler, progressHandler)

• then() 方法只接受 function 对象，其余对象将被忽略
• then() 方法继续返回 Promise 对象，以实现链式调用，用上一个调用的结果作为下一个调用的开始

var readFile = smooth(fs.readFile);
readFile('file1.txt', 'utf-8').then(function (file1) {
    return readFile(file1.trim(), 'utf-8');
}).then(function (file2) {
    console.log(file2);
});

实现

// Promise
var Promise = function() {
    this.queue = [];
    this.isPromise = true;
};
Promise.prototype.then = function (fulfilledHandler, errorHandler, progressHandler) {
    var handler = {};
    // 将事件处理程序绑定在 handler 对象上
    if (typeof fulfilledHandler === 'function') {
        handler.fulfilled = fuldilledHandler;
    }
    if (typeof errorHandler === 'function') {
        handler.error = errorHandler;
    }
    // 将 handler 对象推入队列
    this.queue.push(handler);
    return this;
};
// Deferred
var Deferred = function () {
    this.promise = new Promise();
};
// 完成态
Deferred.prototype.resolve = function (obj) {
    var promise = this.promise;
    var handler;
    // 将队列中的 handler 对象逐个取出
    while ((handler = promise.queue.shift())) {
        // 判断是否有相应状态的处理函数
        if (handler && handler.fulfilled) {
            // 调用处理函数并保存结果
            var ret = handler.fulfilled(obj);
            // 用返回的 promise 对象替代原本的，因为每 Promise 化一个函数都会新建一个 Deferred
            if (ret && ret.isPromise) {
                ret.queue = promise.queue;
                this.promise = ret;
                return;
            }
        }
    }
};
// 失败态
Deferred.prototype.reject = function (obj) {
    var promise = this.promise;
    var handler;
    while ((handler = promise.queue.shift())) {
        if (handler && handler.error) {
            var ret = handler.error(obj);
            if (ret && ret.isPromise) {
                ret.queue = promise.queue;
                this.promise = ret;
                return;
            }
        }
    }
};
// 生成回调函数，在异步方法中传入这个函数
Deferred.prototype.callback = function () {
    //将 this 传入回调函数
    var that = this;
    return function (err, file) {
        if (err) {
            return that.reject(err);
        }
        that.resolve(file);
    };
};
// 将方法 Promise 化
var smooth = function(method) {
    return function () {
        var deferred = new Deferred();
        var args = Array.prototype.slice.call(arguments, 0);
        args.push(deferred.callback());
        method.apply(null, args);
        return deferred.promise;
    };
};