深入剖析 Unity 协程的实现原理

MonoBehaviour::StartCoroutineManaged2(ScriptingObjectPtr enumerator)
{
    Coroutine* coroutine = CreateCoroutine(enumerator, SCRIPTING_NULL);
    return 封装过的Coroutine对象;
}

Coroutine* MonoBehaviour::CreateCoroutine(ScriptingObjectPtr userCoroutine, ScriptingMethodPtr method)
{
    获取moveNext;
    获取current;
    
    Coroutine* coroutine = new Coroutine ();
    初始化coroutine对象;    //这个时候就会把moveNext和current传递给coroutine对象
    
    m_ActiveCoroutines.push_back (*coroutine);
    m_ActiveCoroutines.back ().Run ();
    ...
    return coroutine;
}

void Coroutine::Run ()
{
    // - Call MoveNext (处理迭代器块的逻辑直到遇到yield return)
    // - Call Current (返回一个条件，何时可以执行下一个moveNext)
    
    //根据IEnumerator的特性，首先得调用下MoveNext，这样current就被赋值了
    bool keepLooping = InvokeMoveNext(&exception);    
    
    ProcessCoroutineCurrent();
}

void Coroutine::ProcessCoroutineCurrent()
{
    //调用Current，并从中取出yield return的返回对象monoWait
    ScriptingInvocation invocation(m_Current);
    ...
    ScriptingObjectPtr monoWait = invocation.Invoke(&exception);
   
    //yield return null
    if (monoWait == SCRIPTING_NULL)
    {
        ...
        //wait的时间就是0，相当于等一帧
        CallDelayed (ContinueCoroutine, m_Behaviour, 0.0F, this, 0.0F, CleanupCoroutine, DelayedCallManager::kRunDynamicFrameRate | DelayedCallManager::kWaitForNextFrame);
        return;
    }
    
    HandleIEnumerableCurrentReturnValue(monoWait);
}

void Coroutine::HandleIEnumerableCurrentReturnValue(ScriptingObjectPtr monoWait)
{
    ScriptingClassPtr waitClass = scripting_object_get_class (monoWait, GetScriptingTypeRegistry());
    const CommonScriptingClasses& classes = GetMonoManager ().GetCommonClasses ();
    
    //yield return new WaitForSeconds()
    if (scripting_class_is_subclass_of (waitClass, classes.waitForSeconds))
    {
        float wait;
        通过monoWait获取需要wait的时间;
        CallDelayed(ContinueCoroutine, m_Behaviour, wait, this, 0.0F, CleanupCoroutine, DelayedCallManager::kRunDynamicFrameRate | DelayedCallManager::kWaitForNextFrame);
        return;  
    }
    
    //yield reuturn new WaitForFixedUpdate()
    if (scripting_class_is_subclass_of (waitClass, classes.waitForFixedUpdate))
    {
        CallDelayed (ContinueCoroutine, m_Behaviour, 0.0F, this, 0.0F, CleanupCoroutine, DelayedCallManager::kRunFixedFrameRate);
        return;  
    }
    
    //yield return new WaitForEndOfFrame()
    if (scripting_class_is_subclass_of (waitClass, classes.waitForEndOfFrame))
    {
        CallDelayed (ContinueCoroutine, m_Behaviour, 0.0F, this, 0.0F, CleanupCoroutine, DelayedCallManager::kEndOfFrame);
        return;  
    }
    
    //yield return 另一个协程
    if (scripting_class_is_subclass_of (waitClass, classes.coroutine))
	{
        Coroutine* waitForCoroutine;
        ...
        if(waitForCoroutine->m_DoneRunning)
        {
            ContinueCoroutine(m_Behavoir, this);
            return;
        }
        ...
	    return;  
	}
    
    //yield return www
    if (scripting_class_is_subclass_of (waitClass, classes.www))
    {
        WWW* wwwPtr;
        if(wwwPtr != NULL)
        {
            //WWW类型比较特殊它本身做了类似的处理，它提供了一个方法CallWhenDone，当它完成的时候直接回调Coroutine。
            wwwPtr->CallWhenDone(ContinueCoroutine, m_Behaviour, this, CleanupCoroutine);
        }
        return;  
    }
}

void Coroutine::ContinueCoroutine (Object* o, void* userData)
{
    Coroutine* coroutine = (Coroutine*)userData;
    if((Object*)coroutine->m_Behaviour != o)
    {
        ...
        reutrn;
    }
    coroutine->Run();
}

//这个枚举型就是下面用到的mode
enum  {
    kRunFixedFrameRate = 1 << 0,
    kRunDynamicFrameRate = 1 << 1,
    kRunStartupFrame = 1 << 2,
    kWaitForNextFrame = 1 << 3,
    kAfterLoadingCompleted = 1 << 4,
    kEndOfFrame = 1 << 5
};

void CallDelayed (DelayedCall *func, PPtr<Object> o, float time, void* userData, float repeatRate, CleanupUserData* cleanup, int mode)
{
    DelayedCallManager::Callback callback;
    
    callback.time = time + GetCurTime ();
    callback.userData = userData;
    callback.call = func;
    callback.cleanup = cleanup;
    callback.object = o;
    callback.mode = mode;
    ...
        
    //将callback保存在DelayedCallManager的Callback List中
    GetDelayedCallManager ().m_CallObjects.insert (callback);
}

void DelayedCallManager::Update (int modeMask)
{
    float time = GetCurTime();
    Container::iterator i = m_CallObjects.begin ();
    
    while (i !=  m_CallObjects.end () && i->time <= time)
    {
        m_NextIterator = i;	m_NextIterator++;
        Callback &cb = const_cast<Callback&> (*i);
        
        // - 确保modeMask匹配
        // - 不执行那些在DelayedCallManager::Update中被添加进来的delayed calls
        if((cb.mode & modeMask) && cb.timeStamp != m_TimeStamp && cb.frame <= frame)
        {
            void* userData = cb.userData;
            DelayedCall* callback = cb.call;
            
            if (!cb.repeat)
            {
                从callback列表中移除即将被执行的callback;
                callback (o, userData);    //执行callback
                清除userData;
            }
            else
            {
                //增加时间后并重新插入callback列表中
                cb.time += cb.repeatRate;
                ...
                m_CallObjects.insert (cb);
                
                从callback列表中移除即将被执行的callback;
                callback (o, userData);    //执行callback
            }
        }
        
        i = m_NextIterator;
    }
}