您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

扒開 RunLoop 源碼:五大結構體與一個 do-while 迴圈

編輯:iOS 開發基礎

為了讓文章保持精簡,這裡只摘錄部分關鍵程式碼。

一、初遇 RunLoop

應該是一個美好的下午,在一場面試中遇見了 RunLoop,可惜擦肩而過。於是想把它讀明白。

二、認識 RunLoop

CFRunLoop

struct __CFRunLoop {
    pthread_t _pthread;               // runLoop 對應的線程
    __CFPort _wakeUpPort;             // 用來喚醒 runLoop 的端口,接收消息後執行 CFRunLoopWakeUp
    CFMutableSetRef _commonModes;     // 所有標記為 common 的 mode 集合
    CFMutableSetRef _commonModeItems; // commonMode 的 item(observers/sources/timers)集合
    CFRunLoopModeRef _currentMode;    // 當前 runLoop 運行的 mode
    CFMutableSetRef _modes;           // 所有 mode 的集合
};

從源碼不難看出:一個 runLoop 物件主要包含一個線程 _pthread、一個喚醒端口 _wakeUpPort、一個當前運行的 mode _currentMode,以及若干 _modes、_commonModes、_commonModeItems。runLoop 可以有很多 mode,但 _currentMode 只有一個——同一時刻,runLoop 只能運行在一個 mode 之下。

CFRunLoopMode

struct __CFRunLoopMode {
    CFStringRef _name;                  // mode 的名字,唯一標識
    Boolean _stopped;                   // mode 的狀態,是否已停止
    CFMutableSetRef _sources0;          // sources0 集合
    CFMutableSetRef _sources1;          // sources1 集合
    CFMutableArrayRef _observers;       // 觀察者陣列
    CFMutableArrayRef _timers;          // 定時器陣列
    // 源碼中有:CFDictionarySetValue(rlm->_portToV1SourceMap, ..., rls);
    CFMutableDictionaryRef _portToV1SourceMap; // key 是 __CFPort,value 是 CFRunLoopSourceRef
    // 源碼中有:__CFPortSetInsert(src_port, rlm->_portSet);
    __CFPortSet _portSet;               // 端口集合
}

由此可見分工很清楚:mode 管理所有事件(sources / timers / observers),runLoop 管理 mode。

CFRunLoopSource

struct __CFRunLoopSource {
    CFMutableBagRef _runLoops;   // 一個 Source 可以對應多個 runLoop
    union {
        CFRunLoopSourceContext version0;  // source0
        CFRunLoopSourceContext1 version1; // source1
    } _context;
};

// source0
typedef struct {
    CFIndex version;   // 版本號,用來區分 source0 還是 source1
    void *info;
    void (*schedule)(void *info, CFRunLoopRef rl, CFStringRef mode);
    void (*cancel)(void *info, CFRunLoopRef rl, CFStringRef mode);
    void (*perform)(void *info);  // 回調指針
} CFRunLoopSourceContext;

// source1
typedef struct {
    CFIndex version;
    void *info;
    mach_port_t (*getPort)(void *info);                                  // 端口
    void *(*perform)(void *msg, CFIndex size, CFAllocatorRef allocator, void *info); // 回調指針
} CFRunLoopSourceContext1;

兩者的差異很明確:source1 比 source0 多了一個用來接收消息的 mach_port_t。

CFRunLoopObserver

struct __CFRunLoopObserver {
    CFRunLoopRef _runLoop;    // observer 對應的 runLoop,一一對應
    CFIndex _rlCount;         // observer 當前監測的 runLoop 數量,用在安排/移除 runLoop 時
    CFOptionFlags _activities;// observer 觀測的 runLoop 狀態,列舉型別
    CFIndex _order;           // mode 用陣列存 observers,依 _order 決定插入位置
    CFRunLoopObserverCallBack _callout;
};

_activities 的取值:

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),        // 即將進入 Loop
    kCFRunLoopBeforeTimers = (1UL << 1), // 即將處理 Timers
    kCFRunLoopBeforeSources = (1UL << 2),// 即將處理 Sources
    kCFRunLoopBeforeWaiting = (1UL << 5),// 即將進入休眠
    kCFRunLoopAfterWaiting = (1UL << 6), // 剛從休眠中被喚醒
    kCFRunLoopExit = (1UL << 7),         // 即將退出 RunLoop
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};

CFRunLoopTimer

struct __CFRunLoopTimer {
    CFRunLoopRef _runLoop;   // timer 對應的 runLoop
    CFMutableSetRef _rlModes;// 對應的 modes 集合,可見一個 timer 能加入多個 mode
    CFRunLoopTimerCallBack _callout;
};

三、了解 RunLoop:五個類之間的關鍵方法

CFRunLoopCopyCurrentMode

取得 runLoop 正在運行的 mode(即 _currentMode)的 name。

CFStringRef CFRunLoopCopyCurrentMode(CFRunLoopRef rl) {
    CFStringRef result = NULL;
    result = (CFStringRef)CFRetain(rl->_currentMode->_name);
    return result;
}

CFRunLoopCopyAllModes

回傳一個陣列,包含 runLoop 所有已定義過的 mode(即 _modes)的 name。

CFArrayRef CFRunLoopCopyAllModes(CFRunLoopRef rl) {
    CFMutableArrayRef array;
    array = CFArrayCreateMutable(kCFAllocatorSystemDefault, CFSetGetCount(rl->_modes), &kCFTypeArrayCallBacks);
    // CFSetApplyFunction(a, b, c):對 a 中的每個元素執行一次 b,b 的參數是 a 與 c
    CFSetApplyFunction(rl->_modes, (__CFRunLoopGetModeName), array);
    return array;
}

// 把 mode 的 name 加進 array
static void __CFRunLoopGetModeName(const void *value, void *context) {
    CFRunLoopModeRef rlm = (CFRunLoopModeRef)value;
    CFMutableArrayRef array = (CFMutableArrayRef)context;
    CFArrayAppendValue(array, rlm->_name);
}

CFRunLoopAddCommonMode

向 runLoop 的 commonModes 加入一個 mode。

void CFRunLoopAddCommonMode(CFRunLoopRef rl, CFStringRef modeName) {
    // 若 modeName 已在 _commonModes 中,else 分支不做任何處理
    if (!CFSetContainsValue(rl->_commonModes, modeName)) {
        // set 是 runLoop 的 _commonModeItems 的一份拷貝
        CFSetRef set = rl->_commonModeItems
            ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModeItems)
            : NULL;

        // 1. 把 modeName 加入 _commonModes(可見 _commonModes 存的是 CFStringRef 型別的 modeName)
        CFSetAddValue(rl->_commonModes, modeName);

        if (NULL != set) {
            CFTypeRef context[2] = {rl, modeName};
            // 2. 為該 modeName 對應的 Mode 加入 set 中的每個 item(timer/source/observer)
            CFSetApplyFunction(set, (__CFRunLoopAddItemsToCommonMode), (void *)context);
        }
    } else {
    }
}

// 把一個 item 加入指定的 mode
static void __CFRunLoopAddItemsToCommonMode(const void *value, void *ctx) {
    CFTypeRef item = (CFTypeRef)value;
    CFRunLoopRef rl = ((CFTypeRef *)ctx)[0];
    CFStringRef modeName = (CFStringRef)((CFTypeRef *)ctx)[1];

    // 判斷 item 的具體型別,分別加入
    if (CFGetTypeID(item) == CFRunLoopSourceGetTypeID()) {
        CFRunLoopAddSource(rl, (CFRunLoopSourceRef)item, modeName);
    } else if (CFGetTypeID(item) == CFRunLoopObserverGetTypeID()) {
        CFRunLoopAddObserver(rl, (CFRunLoopObserverRef)item, modeName);
    } else if (CFGetTypeID(item) == CFRunLoopTimerGetTypeID()) {
        CFRunLoopAddTimer(rl, (CFRunLoopTimerRef)item, modeName);
    }
}

CFRunLoopAddSource

把一個 source 加入指定的 runLoopMode。

它的邏輯分成兩大分支:

  1. 若 modeName 是 kCFRunLoopCommonModes:先把 rls 加入 _commonModeItems,再遍歷 _commonModes 中的所有 mode,為它們逐一加上這個 rls。
  2. 非 commonMode:先透過 __CFRunLoopFindMode(rl, modeName, true) 找到(找不到就建立)對應的 mode,初始化與 source 相關的 _sources0、_sources1、_portToV1SourceMap,然後依型別分流:
// source0
if (0 == rls->_context.version0.version) {
    CFSetAddValue(rlm->_sources0, rls);
    // source0 有 schedule 指針,把 rl 與 rlm 關聯起來
    rls->_context.version0.schedule(rls->_context.version0.info, rl, modeName);
}
// source1
else if (1 == rls->_context.version0.version) {
    CFSetAddValue(rlm->_sources1, rls);
    // 取得 rls 的端口
    __CFPort src_port = rls->_context.version1.getPort(rls->_context.version1.info);
    // rls 與端口一一對應,存進 mode 的 _portToV1SourceMap
    CFDictionarySetValue(rlm->_portToV1SourceMap, (const void *)(uintptr_t)src_port, rls);
    // 把 source1 的端口加入 mode 的 _portSet
    __CFPortSetInsert(src_port, rlm->_portSet);
}
// 把 rl 加入 rls 的 _runLoops,即一個 source 可以對應多個 runLoop
if (NULL == rls->_runLoops) {
    rls->_runLoops = CFBagCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeBagCallBacks);
}
CFBagAddValue(rls->_runLoops, rl);

CFRunLoopAddObserver

把 observer 加入指定的 mode。

內部實現與 CFRunLoopAddSource 大同小異,同樣要判斷是否為 commonMode,差別在兩處:

  • 關聯 mode:mode 有一個陣列 _observers,插入位置依 observer 的 _order 決定。
  • 關聯 runLoop:依 _rlCount 是否為 0 判斷,只有當 observer 的 _rlCount 為 0 時,它的 _runLoop 才會被設為該 rl。

CFRunLoopAddTimer

把 timer 加入指定的 mode。

實現思路相同,但有幾點值得注意:

  1. timer 只能加入到自己 _runLoop 的 mode。若傳入的 rl 不是它的 _runLoop,直接返回:
if (NULL == rlt->_runLoop) {
    rlt->_runLoop = rl;
} else if (rl != rlt->_runLoop) {
    __CFRunLoopTimerUnlock(rlt);
    __CFRunLoopModeUnlock(rlm);
    __CFRunLoopUnlock(rl);
    return;
}
  1. timer 有一個 _rlModes,存的是它所加入的 mode 的 name:
CFSetAddValue(rlt->_rlModes, rlm->_name);
  1. mode 的 _timers 陣列是依 timer 的觸發時間 _fireTSR 排序的。

四、取得 RunLoop

runLoop 與其所在線程一一對應。

API 提供了兩個取得方式:

CFRunLoopRef CFRunLoopGetMain(void) {
    static CFRunLoopRef __main = NULL; // 無需 retain
    if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // 主線程
    return __main;
}

CFRunLoopRef CFRunLoopGetCurrent(void) {
    CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
    if (rl) return rl;
    return _CFRunLoopGet0(pthread_self()); // 當前線程
}

這裡的 TSD 是 Thread Specific Data(線程私有資料)。在 C++ 中,全域變數所有線程都能存取,區域變數只有函式內部能存取,而 TSD 的用處是:在同一個線程的不同函式之間共享資料。__CFTSDKeyRunLoop 是一個列舉型別的關鍵字。

從 pthread_self() 可以看出:要取得非主線程的 runLoop,必須在該線程內部呼叫 CFRunLoopGetCurrent。

再往下是依線程 t 取得對應 runLoop 的 _CFRunLoopGet0,它的實現可分為幾步:

  1. 保證 t 不為空,若為 kNilPthreadT 則退回主線程。
  2. 建立全域字典 __CFRunLoops,並在其中建立、存入主線程的 runLoop;這裡用 OSAtomicCompareAndSwapPtrBarrier 做比較並交換,保證多線程下的安全(volatile 的作用是每次都直接從記憶體取值)。CoreFoundation 需要手動管理記憶體,create 對應 release,所以最後要 CFRelease。
  3. 從全域字典中取出 t 對應的 runLoop;若不存在,就建立一個 newLoop,再取一次,仍不存在才真正寫入字典(雙重檢查)。
  4. 若 t 就是當前線程,則註冊 TSD,並註冊銷毀回呼——線程銷毀時,其對應的 runLoop 也會一併銷毀。

結論:線程與 runLoop 一一對應,全存在一個全域字典裡。主線程的 runLoop 在字典初始化時就已建立,其他線程的 runLoop 則是第一次被取得時才建立。

五、運行 RunLoop

CFRunLoopRun

預設情況下,運行當前線程的 runLoop。

void CFRunLoopRun(void) {
    int32_t result;
    do {
        result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
    } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}

由此可得兩點:

  1. kCFRunLoopDefaultMode:預設情況下 runLoop 就在這個 mode 下運行。
  2. runLoop 的主體是一個 do..while 迴圈,除非被停止或結束,否則會一直運行下去。

CFRunLoopRunInMode

在指定 mode 下運行當前線程的 runLoop。

SInt32 CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {
    return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}

它可以指定運行在哪個 mode(modeName)、超時時間(seconds),以及是否處理完一個事件就返回(returnAfterSourceHandled)。

CFRunLoopRunSpecific

在指定 mode 下,運行指定的 runLoop。

SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName,
                            CFTimeInterval seconds, Boolean returnAfterSourceHandled) {
    // 依 rl 與 modeName 找到指定的 currentMode
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);

    // 1. mode 不存在,或 mode 中沒有任何事件,直接結束,回傳 kCFRunLoopRunFinished
    if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
        Boolean did = false;
        return did ? kCFRunLoopRunHandledSource : kCFRunLoopRunFinished;
    }

    int32_t result = kCFRunLoopRunFinished;

    // 2. kCFRunLoopEntry:通知 observers 即將開始循環
    if (currentMode->_observerMask & kCFRunLoopEntry)
        __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);

    // runLoop 的運行主體
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);

    // 3. kCFRunLoopExit:通知 observers 即將退出循環
    if (currentMode->_observerMask & kCFRunLoopExit)
        __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);

    return result;
}

三個要點:mode 中沒有事件就直接回傳 kCFRunLoopRunFinished;進入時拋 kCFRunLoopEntry;退出時拋 kCFRunLoopExit。

__CFRunLoopRun

runLoop 從開始運行到退出的全部邏輯都在這裡。

它先做幾件準備工作:若 runLoop 或 mode 已處於停止狀態,直接回傳 kCFRunLoopRunStopped;接著取得主線程接收消息的端口 dispatchPort、執行 timers 的 modeQueuePort,並建立一個由 GCD 管理的 timeout_timer 來實現超時機制;然後依 seconds 的三種情況(立即超時/即將超時/較遠)設定 termTSR。

之後進入 do..while 主迴圈,其流程如下:

  1. 若 runLoop 或 mode 已停止,直接回傳 kCFRunLoopRunStopped。
  2. 取得 mode 的端口集合 waitSet = rlm->_portSet,並把 runLoop 標記為可被喚醒。
  3. 通知 observers:kCFRunLoopBeforeTimers(即將處理 Timers)。
  4. 通知 observers:kCFRunLoopBeforeSources(即將處理 Sources)。
  5. 處理 source0 事件(__CFRunLoopDoSources0)。內部邏輯是:只有被標記為 Signaled 的 source0 才會被處理,處理前會先移除標記;處理完畢後再執行 __CFRunLoopDoBlocks。
  6. 計算 poll 變數:source0 已處理完且未超時則為 false,否則為 true。
  7. 訊息處理(source1):首次循環時 didDispatchPortLastTime 為 true,會跳過這一步;後續循環會先嘗試從 dispatchPort 非阻塞地取消息,收到就立刻跳轉到 handle_msg。
  8. 把 didDispatchPortLastTime 設為 false,若不需要 poll,則通知 observers:kCFRunLoopBeforeWaiting(即將休眠),然後呼叫 __CFRunLoopSetSleeping。
  9. 線程進入休眠,直到被以下任一事件喚醒:
    • 基於 port 的 Source1 事件
    • Timer 到時間了
    • runLoop 啟動時設定的最大超時時間到了
    • 被手動喚醒
  10. 喚醒後通知 observers:kCFRunLoopAfterWaiting。
  11. 在 handle_msg: 標籤處處理消息,依喚醒源分五種情況:
    • livePort 為 MACH_PORT_NULL:空喚醒,繼續下一輪。
    • 喚醒端口是 rl->_wakeUpPort:重設事件,回到第 2 步。
    • 喚醒端口是 modeQueuePort:定時器事件,交給 __CFRunLoopDoTimers 處理,必要時 __CFArmNextTimerInMode 掛上下一個定時器。
    • 喚醒端口是 dispatchPort:交給 __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__ 處理主隊列。
    • 其他端口:視為 source1 事件,用 __CFRunLoopModeFindSourceForMachPort 找到對應 source,交給 __CFRunLoopDoSource1 處理,若有回覆消息則用 mach_msg 送回。
  12. 決定返回值,並判斷是否跳出迴圈:
    • 事件處理完且 stopAfterHandle 為真 → kCFRunLoopRunHandledSource
    • 已超時 → kCFRunLoopRunTimedOut
    • 被外部強制停止 → kCFRunLoopRunStopped
    • mode 狀態為停止 → kCFRunLoopRunStopped
    • source / timer / observer 全都沒有了 → kCFRunLoopRunFinished

以上五種情形會跳出 do..while,其餘情況則繼續循環。最終回傳值只有四種列舉:kCFRunLoopRunFinished、kCFRunLoopRunStopped、kCFRunLoopRunTimedOut、kCFRunLoopRunHandledSource。

總結

1. runLoop 與線程一一對應,非主線程的 runLoop 只能在其內部取得;runLoop 管理 mode 與回調 block,而 mode 存儲了所有事件。

2. runLoop 的核心就是一個 do..while 迴圈:遍歷所有事件,有事件就處理,沒有就休眠,直到觸發退出條件。

3. 以上是 RunLoop 內部源碼的梳理,難免有理解不到位之處,也仍有待深挖的問題,歡迎指正。

參考資料:〈深入理解 RunLoop〉、〈RunLoop 系列之源碼分析〉、Apple 官方 Run Loops 與 CFRunLoop 文件。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved