JSCore运行时(二)-Promise的实现

Promise

首先，我们看下JS里面promise的实现，注意这里带有@符号前缀的方法有部分是由对应的C++方法实现的，可以在工程里根据方法名字搜索
先看下构造方法

@globalPrivate
function initializePromise(executor)
{
    "use strict";

    if (typeof executor !== 'function')
        @throwTypeError("Promise constructor takes a function argument");
    //设置promiseState为pending
    @putByIdDirectPrivate(this, "promiseState", @promiseStatePending);
    //初始化promiseReactions数组
    @putByIdDirectPrivate(this, "promiseReactions", []);
    @putByIdDirectPrivate(this, "promiseIsHandled", false);
   //创建解决函数，也就是resolve和reject
    var resolvingFunctions = @createResolvingFunctions(this);
    try {
        executor(resolvingFunctions.@resolve, resolvingFunctions.@reject);
    } catch (error) {
        return resolvingFunctions.@reject.@call(@undefined, error);
    }

    return this;
}

@globalPrivate
function createResolvingFunctions(promise)
{
    "use strict";

    var alreadyResolved = false;

    function @resolve(resolution) {
        if (alreadyResolved)
            return @undefined;
        alreadyResolved = true;
       //如果resolve的函数就是promise本身，则报错
        if (resolution === promise)
            return @rejectPromise(promise, new @TypeError("Resolve a promise with itself"));

        if (!@isObject(resolution))
            return @fulfillPromise(promise, resolution);
        //尝试获取then
        var then;
        try {
            then = resolution.then;
        } catch (error) {
            //出现错误，则调用reject
            return @rejectPromise(promise, error);
        }

        if (typeof then !== 'function')
            return @fulfillPromise(promise, resolution);
        //获取成功的话，往任务队列中追加一个promiseResolveThenableJob任务
        @enqueueJob(@promiseResolveThenableJob, [promise, resolution, then]);

        return @undefined;
    }

    function @reject(reason) {
        if (alreadyResolved)
            return @undefined;
        alreadyResolved = true;

        return @rejectPromise(promise, reason);
    }

    return { @resolve, @reject };
}

@globalPrivate
//这个任务的作用就是调用promise的then函数，并捕获异常
function promiseResolveThenableJob(promiseToResolve, thenable, then)
{
    "use strict";

    var resolvingFunctions = @createResolvingFunctions(promiseToResolve);

    try {
        return then.@call(thenable, resolvingFunctions.@resolve, resolvingFunctions.@reject);
    } catch (error) {
        return resolvingFunctions.@reject.@call(@undefined, error);
    }
}

再看下fullfill和reject

@globalPrivate
function triggerPromiseReactions(state, reactions, argument)
{
    "use strict";
    //把所有的reactions(resolve和reject的组合)取出来放入队列执行
    for (var index = 0, length = reactions.length; index < length; ++index)
        @enqueueJob(@promiseReactionJob, [state, reactions[index], argument]);
}

@globalPrivate
function rejectPromise(promise, reason)
{
    "use strict";

    var reactions = @getByIdDirectPrivate(promise, "promiseReactions");
    @putByIdDirectPrivate(promise, "promiseResult", reason);
    @putByIdDirectPrivate(promise, "promiseReactions", @undefined);
    @putByIdDirectPrivate(promise, "promiseState", @promiseStateRejected);
    //这里引入了inspector，对promise做性能检测
    @InspectorInstrumentation.promiseRejected(promise, reason, reactions);

    if (!@getByIdDirectPrivate(promise, "promiseIsHandled"))
        @hostPromiseRejectionTracker(promise, @promiseRejectionReject);

    @triggerPromiseReactions(@promiseStateRejected, reactions, reason);
}

@globalPrivate
function fulfillPromise(promise, value)
{
    "use strict";

    var reactions = @getByIdDirectPrivate(promise, "promiseReactions");
    @putByIdDirectPrivate(promise, "promiseResult", value);
    @putByIdDirectPrivate(promise, "promiseReactions", @undefined);
    @putByIdDirectPrivate(promise, "promiseState", @promiseStateFulfilled);
    //这里引入了inspector，对promise做性能检测
    @InspectorInstrumentation.promiseFulfilled(promise, value, reactions);

    @triggerPromiseReactions(@promiseStateFulfilled, reactions, value);
}

在PromiseProtoType.js里面我们可以看到 then方法的具体实现

function then(onFulfilled, onRejected)
{
    "use strict";

    if (!@isPromise(this))
        @throwTypeError("|this| is not a object");

    var constructor = @speciesConstructor(this, @Promise);

    var resultCapability = @newPromiseCapability(constructor);

    if (typeof onFulfilled !== "function")
        onFulfilled = function (argument) { return argument; };

    if (typeof onRejected !== "function")
        onRejected = function (argument) { throw argument; };
    //把resolve和reject包装一下
    var reaction = @newPromiseReaction(resultCapability, onFulfilled, onRejected);

    var state = @getByIdDirectPrivate(this, "promiseState");
     //如果还是处于pending状态，则把新创建的reaction加入到reactions里面
    if (state === @promiseStatePending) {
        var reactions = @getByIdDirectPrivate(this, "promiseReactions");
        @putByValDirect(reactions, reactions.length, reaction);
    } else {//其他状态，rejected或者fullfilled
        if (state === @promiseStateRejected && !@getByIdDirectPrivate(this, "promiseIsHandled"))
            @hostPromiseRejectionTracker(this, @promiseRejectionHandle);
        //这时候Promise本身的任务已经执行完了，调用then则直接把任务加到队列里执行
        @enqueueJob(@promiseReactionJob, [state, reaction, @getByIdDirectPrivate(this, "promiseResult")]);
    }

    @putByIdDirectPrivate(this, "promiseIsHandled", true);

    return resultCapability.@promise;
}

Promise.then()调用了enqueueJob ，而enqueueJob实际则先创建了一个microTask，然后调用了queueMicroTask加到任务队列里面。

static EncodedJSValue JSC_HOST_CALL enqueueJob(ExecState* exec)
{
    VM& vm = exec->vm();
    JSGlobalObject* globalObject = exec->lexicalGlobalObject();

    JSValue job = exec->argument(0);
    JSValue arguments = exec->argument(1);
    ASSERT(arguments.inherits<JSArray>(vm));

    globalObject->queueMicrotask(createJSJob(vm, job, jsCast<JSArray*>(arguments)));

    return JSValue::encode(jsUndefined());
}

MicroTask

这里解释下MicroTask
MicroTask是一个抽象类，定义了run接口，用于执行一小段任务。

而JSJobMicroTask是他的具体实现，继承自microTask，实现了run接口

class JSJobMicrotask final : public Microtask {
public:
    JSJobMicrotask(VM& vm, JSValue job, JSArray* arguments)
    {
        m_job.set(vm, job);
        m_arguments.set(vm, arguments);
    }

    virtual ~JSJobMicrotask()
    {
    }

private:
    void run(ExecState*) override;

    Strong<Unknown> m_job;
    Strong<JSArray> m_arguments;
};

Ref<Microtask> createJSJob(VM& vm, JSValue job, JSArray* arguments)
{
    return adoptRef(*new JSJobMicrotask(vm, job, arguments));
}

void JSJobMicrotask::run(ExecState* exec)
{
    VM& vm = exec->vm();
    //获取作用域
    auto scope = DECLARE_CATCH_SCOPE(vm);

    CallData handlerCallData;
    CallType handlerCallType = getCallData(vm, m_job.get(), handlerCallData);
    ASSERT(handlerCallType != CallType::None);
   //检查参数合法性
    MarkedArgumentBuffer handlerArguments;
    for (unsigned index = 0, length = m_arguments->length(); index < length; ++index) {
        JSValue arg = m_arguments->JSArray::get(exec, index);
        CLEAR_AND_RETURN_IF_EXCEPTION(scope, handlerArguments.overflowCheckNotNeeded());
        handlerArguments.append(arg);
    }
    if (UNLIKELY(handlerArguments.hasOverflowed()))
        return;
    //执行调用
    profiledCall(exec, ProfilingReason::Microtask, m_job.get(), handlerCallType, handlerCallData, jsUndefined(), handlerArguments);
    scope.clearException();
}

}

run的作用: 获取scope,检查参数合法性，调用profiledCall执行任务
run在drainMicroTask中被调用。

MicroTaskQueue

任务队列，是VM的一个成员变量，名称叫m_microTaskQueue, 相关的方法有两个，一个是queueMicroTask，一个是drainMicroTask.

void VM::queueMicrotask(JSGlobalObject& globalObject, Ref<Microtask>&& task)
{ 
   //把任务加入队列末尾
    m_microtaskQueue.append(std::make_unique<QueuedTask>(*this, &globalObject, WTFMove(task)));
}

void VM::drainMicrotasks()
{
  //把队列中所有任务取出来执行(每次从队列头部取出任务)
    while (!m_microtaskQueue.isEmpty())
        m_microtaskQueue.takeFirst()->run();
}

drainMicroTask调用的地方有几个:

jsc.cpp 里面，比如runWithOptions、runInteractive、runJSC，调用jsCore时执行。
promiseDeferredTimer的doWork函数里面,执行某个延时操作时调用

jsc.cpp

jsc.cpp是javascriptCore工程的main文件，即程序启动的入口文件。调用runJSC就是开始运行javascriptCore。runJSC里面开启了runloop，在mac os和ios上就是CFRunloop,其他平台上也是类似的运行循环。在runJSC里面还启动了一个PromiseDeferredTimer,用来处理延迟操作

template<typename Func>
int runJSC(CommandLine options, bool isWorker, const Func& func)
{
    Worker worker(Workers::singleton());
    
    VM& vm = VM::create(LargeHeap).leakRef();
    int result;
    bool success = true;
    GlobalObject* globalObject = nullptr;
    {
        JSLockHolder locker(vm);

        if (options.m_profile && !vm.m_perBytecodeProfiler)
            vm.m_perBytecodeProfiler = std::make_unique<Profiler::Database>(vm);

        globalObject = GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), options.m_arguments);
        globalObject->setRemoteDebuggingEnabled(options.m_enableRemoteDebugging);
        func(vm, globalObject, success);
        //取出队列中的所有任务并执行
        vm.drainMicrotasks();
    }
    //开启runloop，执行定时任务
    vm.promiseDeferredTimer->runRunLoop();
    {
        JSLockHolder locker(vm);
        if (options.m_interactive && success)
            runInteractive(globalObject);
    }
   //......
}

JSRunLoopTimer

JScore利用CFRunloop的timer执行定时操作，跟iOS的NSTimer类似，有scheduleTimer、cancelTimer等方法。内部持有了CFRunLoopTimerRef类型的一个对象m_timer及CFRunloopRef类型的m_runLoop。
promiseDeferredTimer就是继承于JSRunLoopTimer.

class PromiseDeferredTimer : public JSRunLoopTimer {
public:
    using Base = JSRunLoopTimer;

    PromiseDeferredTimer(VM&);

    void doWork() override;

    void addPendingPromise(JSPromiseDeferred*, Vector<Strong<JSCell>>&& dependencies);
    JS_EXPORT_PRIVATE bool hasPendingPromise(JSPromiseDeferred* ticket);
    JS_EXPORT_PRIVATE bool hasDependancyInPendingPromise(JSPromiseDeferred* ticket, JSCell* dependency);
    // JSPromiseDeferred should handle canceling when the promise is resolved or rejected.
    bool cancelPendingPromise(JSPromiseDeferred*);

    typedef std::function<void()> Task;
    void scheduleWorkSoon(JSPromiseDeferred*, Task&&);

    void stopRunningTasks() { m_runTasks = false; }

    JS_EXPORT_PRIVATE void runRunLoop();

private:
    HashMap<JSPromiseDeferred*, Vector<Strong<JSCell>>> m_pendingPromises;
    Lock m_taskLock;
    bool m_runTasks { true };
    bool m_shouldStopRunLoopWhenAllPromisesFinish { false };
    bool m_currentlyRunningTask { false };
    Vector<std::tuple<JSPromiseDeferred*, Task>> m_tasks;
};

} // namespace JSC

promiseDeferredTimer的doWork是在timerDidFire函数中调用的。用来执行具体的任务，可以看到，这里为了避免多线程同时执行任务，还做了加锁操作，这也提现了javascript单线程的特点。

void PromiseDeferredTimer::doWork()
{
    ASSERT(m_vm->currentThreadIsHoldingAPILock());
    m_taskLock.lock();
    cancelTimer();
    if (!m_runTasks) {
        m_taskLock.unlock();
        return;
    }

    while (!m_tasks.isEmpty()) {
        JSPromiseDeferred* ticket;
        Task task;
        std::tie(ticket, task) = m_tasks.takeLast();
        dataLogLnIf(PromiseDeferredTimerInternal::verbose, "Doing work on promise: ", RawPointer(ticket));

        // We may have already canceled these promises.
        if (m_pendingPromises.contains(ticket)) {
            // Allow tasks we run now to schedule work.
            m_currentlyRunningTask = true;
            m_taskLock.unlock(); 

            task();
            m_vm->drainMicrotasks();

            m_taskLock.lock();
            m_currentlyRunningTask = false;
        }
    }

    if (m_pendingPromises.isEmpty() && m_shouldStopRunLoopWhenAllPromisesFinish) {
#if USE(CF)
        CFRunLoopStop(m_runLoop.get());
#else
        RunLoop::current().stop();
#endif
    }

    m_taskLock.unlock();
}

同样继承自JSRunLoopTimer的还有StopIfNecessaryTimer、IncrementalSweeper和GCActivityCallback，这些都是跟JS内存管理相关的类，这里就不展开讲了，后续会专门开一篇讲垃圾回收的实现。

VM中有一个m_runLoopTimers数组维护JSRunLoopTimer。每次调用registerRunLoopTimer就会往m_runLoopTimers中添加一个JSRunLoopTimer。

void VM::registerRunLoopTimer(JSRunLoopTimer* timer)
{
    ASSERT(runLoop());
    ASSERT(!m_runLoopTimers.contains(timer));
    m_runLoopTimers.add(timer);
    timer->setRunLoop(runLoop());
}

void VM::unregisterRunLoopTimer(JSRunLoopTimer* timer)
{
    ASSERT(m_runLoopTimers.contains(timer));
    m_runLoopTimers.remove(timer);
    timer->setRunLoop(nullptr);
}

这里runloop()是获取当前线程的runloop
我们知道，iOS的runloop是跟线程一一对应的，那么JS的runloop既然是使用了CFRunloop，那也是跟线程一一对应，那么也就不难理解JS里面的任务为什么是串行的了，因为VM里面的runloop只有一个，只能在一个事件循环中按顺序执行。对于Promise是如此，对于其他的异步任务，如Timer、async/await等也是如此。