从 Google V8 引擎剖析 Promise 实现

​ 本文阅读的源码为 Google V8 Engine v3.29.45，此版本的 promise 实现为 js 版本，在后续版本 Google 继续对其实现进行了处理。引入了 es6 语法等，在 7.X 版本迭代后，逐渐迭代成了 C 版本实现。

​ 贴上源码地址：https://chromium.googlesource… 大家自觉传送。

​ 代码中所有类似 %functionName 的函数均是 C 语言实现的运行时函数。

Define variables

首先定义了将要在 JS 作用域使用了一些变量，提高了编译器的效率。

var IsPromise;
var PromiseCreate;
var PromiseResolve;
var PromiseReject;
var PromiseChain;
var PromiseCatch;
var PromiseThen;
var PromiseHasRejectHandler;

随后定义了一些全局私有变量供给和 C 语音交互，用于维护 Promise 的状态和进行 Debug。

var promiseStatus = GLOBAL_PRIVATE("Promise#status");
var promiseValue = GLOBAL_PRIVATE("Promise#value");
var promiseOnResolve = GLOBAL_PRIVATE("Promise#onResolve");
var promiseOnReject = GLOBAL_PRIVATE("Promise#onReject");
var promiseRaw = GLOBAL_PRIVATE("Promise#raw");
var promiseDebug = GLOBAL_PRIVATE("Promise#debug");
var lastMicrotaskId = 0;

其中 GLOBAL_PRIVATE 是 python 进行实现的，运用 python 的宏定义（macro）来定义调用了 C 语言的 CreateGlobalPrivateOwnSymbol 方法。

macro GLOBAL_PRIVATE(name) = (%CreateGlobalPrivateOwnSymbol(name));

随后运用了一个自执行的匿名函数进行闭包逻辑。

(function() {// 主逻辑})();

在闭包逻辑的最后，在 promise 原型上挂载了三个方法：chain，then，catch。在 promise 对象上挂载了 all,race 等六个方法。将 Promise 对象注册到了 global。

%AddNamedProperty(global, 'Promise', $Promise, DONT_ENUM);
InstallFunctions($Promise, DONT_ENUM, [
    "defer", PromiseDeferred,
    "accept", PromiseResolved,
    "reject", PromiseRejected,
    "all", PromiseAll,
    "race", PromiseOne,
    "resolve", PromiseCast
]);
InstallFunctions($Promise.prototype, DONT_ENUM, [
    "chain", PromiseChain,
    "then", PromiseThen,
    "catch", PromiseCatch
]);

Start from constructor

var $Promise = function Promise(resolver) {
    // 如果传入参数为全局 promiseRaw 变量的时候 return
    if (resolver === promiseRaw) return;
    // 如果当前函数不是构造函数的化，抛出错误这不是一个 promise
    if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
    // 如果传入参数不是一个函数的话，抛出错误，传入参数不是一个 function
    if (!IS_SPEC_FUNCTION(resolver))
        throw MakeTypeError('resolver_not_a_function', [resolver]);
    var promise = PromiseInit(this);
    try {
        // debug 相关忽略
        %DebugPushPromise(promise);
        resolver(function(x) {PromiseResolve(promise, x) },
                 function(r) {PromiseReject(promise, r) });
    } catch (e) {
        // 报错之后走到错误处理函数
        PromiseReject(promise, e);
    } finally {
        // debug 相关忽略
        %DebugPopPromise();}
}

构造函数在做完额外的异常和参数判断后，进入主逻辑调用 PromiseInit 方法初始化 promise，随后调用了 resolver 方法，传入了两个默认的处理函数。在 promise 在内部被调用时（PromiseDeferred 方法被调用时）会实例化 $promise, 将默认方法 return 回去，使得创建的 promise 示例具有 resolve 和 reject 方法。

function PromiseDeferred() {if (this === $Promise) {
        // Optimized case, avoid extra closure.
        var promise = PromiseInit(new $Promise(promiseRaw));
        return {
            promise: promise,
            resolve: function(x) {PromiseResolve(promise, x) },
            reject: function(r) {PromiseReject(promise, r) }
        };
    } else {var result = {};
        result.promise = new this(function(resolve, reject) {
            result.resolve = resolve;
            result.reject = reject;
        })
        return result;
    }
}

PromiseInit

function PromiseSet(promise, status, value, onResolve, onReject) {// macro SET_PRIVATE(obj, sym, val) = (obj[sym] = val);
    // 设置 promise 的状态，SET_PRIVATE 只有在给已经存在的对象设置已有属性值的时候才会被调用
    SET_PRIVATE(promise, promiseStatus, status);
    SET_PRIVATE(promise, promiseValue, value);
    SET_PRIVATE(promise, promiseOnResolve, onResolve);
    SET_PRIVATE(promise, promiseOnReject, onReject);
    // debug 代码忽略
    if (DEBUG_IS_ACTIVE) {%DebugPromiseEvent({ promise: promise, status: status, value: value});
    }
    return promise;
}

function PromiseInit(promise) {
    return PromiseSet(promise, 0, UNDEFINED, new InternalArray, new InternalArray)
}

实质上是调用了 PromiseSet 方法给 promise 设置了当前的状态。

PromiseResolve

promiseResolve 方法的调用暴露给外部的 promise.accept(高版本为 resolve)方法，如果当前的 this 指向 promise 的构造函数，则设置当前的 promise 状态，否则调用 resolve 函数执行。

function PromiseResolved(x) {if (this === $Promise) {
        // Optimized case, avoid extra closure.
        return PromiseSet(new $Promise(promiseRaw), +1, x);
    } else {return new this(function(resolve, reject) {resolve(x) });
    }
}

promiseResolve 处理逻辑同 promiseReject，不再赘述。

promise.then

PromiseThen 方法的调用暴露给实例化后的 promise.then 方法调用。

PromiseThen = function PromiseThen(onResolve, onReject) {onResolve = IS_SPEC_FUNCTION(onResolve) ? onResolve
    : PromiseIdResolveHandler;
    onReject = IS_SPEC_FUNCTION(onReject) ? onReject
    : PromiseIdRejectHandler;
    var that = this;
    var constructor = this.constructor;
    return %_CallFunction(
        this,
        function(x) {x = PromiseCoerce(constructor, x);
            return x === that ? onReject(MakeTypeError('promise_cyclic', [x])) :
            IsPromise(x) ? x.then(onResolve, onReject) : onResolve(x);
        },
        onReject,
        PromiseChain
    );
}

首先判断传入的两个参数是否是函数，不是的话添加默认的处理函数，做良好的容错处理。而后调用了 %_CallFunction 方法 (第一个参数是 this，最后一个参数是要调用的方法，中间是传入参数)，类似 Function.prototype.call() 方法，调用了 PromiseChain 方法，传入了两个参数 resolve 和 reject。在 resolve 方法内部调用了 PromiseCoerce 方法，生成对象如果是个 thenable 对象调用对象的 then 方法否则直接 onResolve 方法。

PromiseCoerce

function PromiseCoerce(constructor, x) {if (!IsPromise(x) && IS_SPEC_OBJECT(x)) {
        var then;
        try {then = x.then;} catch(r) {return %_CallFunction(constructor, r, PromiseRejected);
        }
        // macro IS_SPEC_FUNCTION(arg) = (%_ClassOf(arg) === 'Function');
        // 如果是一个 function
        if (IS_SPEC_FUNCTION(then)) {var deferred = %_CallFunction(constructor, PromiseDeferred);
            try {%_CallFunction(x, deferred.resolve, deferred.reject, then);
            } catch(r) {deferred.reject(r);
            }
            return deferred.promise;
        }
    }
    return x;
}

核心的逻辑是如果传入对象的 then 属性是一个 function，则调用 then 方法。若有报错走到 reject 方法。

PromiseChain

PromiseChain = function PromiseChain(onResolve, onReject) {  
    // 补默认的处理函数
    onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
    onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
    var deferred = %_CallFunction(this.constructor, PromiseDeferred);
    switch (GET_PRIVATE(this, promiseStatus)) {
        case UNDEFINED:
            throw MakeTypeError('not_a_promise', [this]);
        case 0:  // Pending
            GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred);
            GET_PRIVATE(this, promiseOnReject).push(onReject, deferred);
            break;
        case +1:  // Resolved
            PromiseEnqueue(GET_PRIVATE(this, promiseValue),
                           [onResolve, deferred],
                           +1);
            break;
        case -1:  // Rejected
            PromiseEnqueue(GET_PRIVATE(this, promiseValue),
                           [onReject, deferred],
                           -1);
            break;
    }
    // debug 代码忽略
    if (DEBUG_IS_ACTIVE) {%DebugPromiseEvent({ promise: deferred.promise, parentPromise: this});
    }
    return deferred.promise;
}

PromiseChain 方法是 promise 实现的核心，判断当前定义的 promise 状态，如果是 pending 状态在 promiseOnResolve 数组中 push 当前的 onResolve 方法。如果是 Resolved 状态或者 Rejected 状态，则调用 PromiseEnqueue 函数进行微任务的添加。

PromiseEnqueue

function PromiseEnqueue(value, tasks, status) {
    var id, name, instrumenting = DEBUG_IS_ACTIVE;
    %EnqueueMicrotask(function() {if (instrumenting) {%DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name});
        }
        for (var i = 0; i < tasks.length; i += 2) {PromiseHandle(value, tasks[i], tasks[i + 1])
        }
        if (instrumenting) {%DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name});
        }
    });
    if (instrumenting) {
        id = ++lastMicrotaskId;
        name = status > 0 ? "Promise.resolve" : "Promise.reject";
        %DebugAsyncTaskEvent({type: "enqueue", id: id, name: name});
    }
}

​ 此步骤其实是将 PromiseHandle 函数加入 JS 运行时的微任务队列中。微任务的队列列表是 C 语言进行维护的，应用 %EnqueueMicrotask 方法进行添加。

PromiseHandle

function PromiseHandle(value, handler, deferred) {
    try {%DebugPushPromise(deferred.promise);
        var result = handler(value);
        if (result === deferred.promise)
            throw MakeTypeError('promise_cyclic', [result]);
        else if (IsPromise(result))
            %_CallFunction(result, deferred.resolve, deferred.reject, PromiseChain);
        else
            deferred.resolve(result);
    } catch (exception) {try { deferred.reject(exception); } catch (e) {}} finally {%DebugPopPromise();
    }
}

此函数处理了传入的方法，是指是调用了 resolve 方法，如果返回的结果依旧是一个 promise 则继续调用 PromiseChain 方法，否则调用新生成的 promise 实例的 resolve 方法，进而实现循坏调用。

promise.all

promise 的 all 方法实现了发送多个 promise 请求，返回一个新的 promise，所有 promise 打到 resolve 状态时触发 resolve 状态，若有一个 promise 被 reject，则返回此 promise 的 reject 原因。

function PromiseAll(values) {var deferred = %_CallFunction(this, PromiseDeferred);
    var resolutions = [];
    if (!%_IsArray(values)) {deferred.reject(MakeTypeError('invalid_argument'));
        return deferred.promise;
    }
    try {
        var count = values.length;
        if (count === 0) {deferred.resolve(resolutions);
        } else {for (var i = 0; i < values.length; ++i) {this.resolve(values[i]).then((function() {// Nested scope to get closure over current i (and avoid .bind).
                        // TODO(rossberg): Use for-let instead once available.
                        var i_captured = i;
                        return function(x) {resolutions[i_captured] = x;
                            if (--count === 0) deferred.resolve(resolutions);
                        };
                    })(),
                    function(r) {deferred.reject(r) }
                );
            }
        }
    } catch (e) {deferred.reject(e)
    }
    return deferred.promise;
}

首先判断传参的合理性，生成一个新的 promise 对象，利用遍历的方式给每个传入的 promise 的 resolve 方法后都追加了 then 方法，使得每个传入的 promise 执行 then 方法后凑执行判断逻辑，当计数 count 的 flag 为 0 的时候，所有 promise resolve 完成，调用新 promise 对象的 resolve 方法，传入新 promise 的 reject 方法作为 then 方法 reject 参数。使得所有 promise 的 reject 函数被调用时都会走到新 promise 对象的 reject，最后返回新生成的 promise。

Summary

Promise 的状态和核心变量均托管到公共的作用域去维护，通过数组的 push 方法去添加 Promise 自定的 resolve 和 reject 方法。并将 resolve 和 reject 方法的执行加入微服务队列中，等到 resolve 方法被调用时执行 resolve(value)方法进行调用。为了实现 promise 的循环嵌套调用，在每次处理 value 之前将处理逻辑之上包裹了一层新的 promise 逻辑，类似(new promise()).then(resolve(value))，思路如下。

var ref = function (value) {if (value && value.then)
        return value;
    return {then: function (callback) {
            // 实例化一个新的 promise
            var result = defer();
            // 进入宏任务队列
            enqueue(function () {result.resolve(callback(value));
            });
            return result.promise;
        }
    };
};

Reference

promise 设计思想：https://github.com/kriskowal/…

JavaScript 执行机制：https://www.jianshu.com/p/17c…