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

深入理解 RunLoop:從 CFRunLoop 源碼到蘋果的實際用法

編輯:iOS 開發基礎

RunLoop 是 iOS 與 OS X 開發中極基礎卻又常被忽略的概念。本文從 CFRunLoop 源碼出發,講清 RunLoop 到底是什麼、底層如何實現,再看蘋果怎樣用它支撐起自動釋放池、延遲回調、觸摸事件與屏幕刷新。

目錄

  • RunLoop 的概念
  • RunLoop 與線程的關係
  • RunLoop 對外的接口
  • RunLoop 的 Mode
  • RunLoop 的內部邏輯
  • RunLoop 的底層實現
  • 蘋果用 RunLoop 實現的功能(AutoreleasePool、事件響應、手勢識別、界面更新、定時器、PerformSelecter、GCD、網絡請求)
  • 實際應用舉例(AFNetworking、AsyncDisplayKit)

RunLoop 的概念

一般來說,一個線程一次只能執行一個任務,做完就退出。如果希望線程能持續待命、隨時處理事件而不退出,通常會寫成這樣的循環:

function loop() {
    initialize();
    do {
        var message = get_next_message();
        process_message(message);
    } while (message != quit);
}

這種模型被稱為 Event Loop,Node.js 的事件處理、Windows 程序的消息循環、OS X/iOS 的 RunLoop 都是它的實現。要點在於兩件事:如何管理事件/消息,以及如何讓線程在空閒時休眠以省資源、有消息時立刻被喚醒。

所以 RunLoop 本質上就是一個對象:它管理自己要處理的事件與消息,並提供一個入口函數執行上面那段循環邏輯。線程進入這個函數後,就一直停留在「接受消息 → 等待 → 處理」的循環裡,直到循環結束才返回。

系統提供了兩個這樣的對象:CFRunLoopRef 位於 CoreFoundation,是純 C 的線程安全 API;NSRunLoop 是基於它的面向對象封裝,但這些 API 並非線程安全。CFRunLoopRef 源碼開放,可從 opensource.apple.com 下載整個 CoreFoundation,拖進 Xcode 工程慢慢看。

RunLoop 與線程的關係

iOS 開發中有兩個線程對象:pthread_t 和 NSThread。蘋果不允許直接創建 RunLoop,只給了兩個自動獲取的函數:CFRunLoopGetMain() 和 CFRunLoopGetCurrent()。其內部邏輯大致如下:

/// 全局的 Dictionary,key 是 pthread_t,value 是 CFRunLoopRef
static CFMutableDictionaryRef loopsDic;
/// 訪問 loopsDic 時的鎖
static CFSpinLock_t loopsLock;

/// 獲取一個 pthread 對應的 RunLoop
CFRunLoopRef _CFRunLoopGet(pthread_t thread) {
    OSSpinLockLock(&loopsLock);

    if (!loopsDic) {
        // 第一次進入時,初始化全局 Dic,並先為主線程創建一個 RunLoop
        loopsDic = CFDictionaryCreateMutable();
        CFRunLoopRef mainLoop = _CFRunLoopCreate();
        CFDictionarySetValue(loopsDic, pthread_main_thread_np(), mainLoop);
    }

    /// 直接從 Dictionary 裡獲取
    CFRunLoopRef loop = CFDictionaryGetValue(loopsDic, thread);

    if (!loop) {
        /// 取不到時,創建一個
        loop = _CFRunLoopCreate();
        CFDictionarySetValue(loopsDic, thread, loop);
        /// 注冊回調,線程銷毀時順便銷毀其 RunLoop
        _CFSetTSD(..., thread, loop, __CFFinalizeRunLoop);
    }

    OSSpinLockUnLock(&loopsLock);
    return loop;
}

CFRunLoopRef CFRunLoopGetMain() {
    return _CFRunLoopGet(pthread_main_thread_np());
}

CFRunLoopRef CFRunLoopGetCurrent() {
    return _CFRunLoopGet(pthread_self());
}

由此可見,線程與 RunLoop 一一對應,映射關係存在一個全局 Dictionary 裡。線程剛創建時並沒有 RunLoop,不主動獲取就永遠不會有;RunLoop 在第一次獲取時創建,在線程結束時銷毀。你也只能在自己的線程內部獲取它(主線程除外)。

RunLoop 對外的接口

CoreFoundation 裡與 RunLoop 相關的有 5 個類:CFRunLoopRef、CFRunLoopModeRef、CFRunLoopSourceRef、CFRunLoopTimerRef、CFRunLoopObserverRef。其中 CFRunLoopModeRef 並未直接對外暴露,只通過 CFRunLoopRef 的接口間接操作。

一個 RunLoop 包含若干 Mode,每個 Mode 又包含若干 Source/Timer/Observer。調用 RunLoop 主函數時只能指定其中一個 Mode(CurrentMode),需要切換只能退出 Loop 再重新進入。這樣做是為了隔離不同組的 Source/Timer/Observer,互不干擾。

CFRunLoopSourceRef 是事件產生的源頭,分兩版:

  • Source0 只包含一個回調,不能主動觸發事件。使用時需先調用 CFRunLoopSourceSignal(source) 標記為待處理,再手動調用 CFRunLoopWakeUp(runloop) 喚醒 RunLoop。
  • Source1 包含一個 mach_port 和一個回調,用於通過內核與其他線程互發消息,能主動喚醒 RunLoop 所屬線程。

CFRunLoopTimerRef 是基於時間的觸發器,與 NSTimer 是 toll-free bridged,可以混用。加入 RunLoop 時會注冊相應時間點,到點後喚醒 RunLoop 執行回調。

CFRunLoopObserverRef 是觀察者,RunLoop 狀態變化時通過回調通知。可觀測的時機有:

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

Source/Timer/Observer 統稱為 mode item,一個 item 可同時加入多個 Mode,但重複加入同一個 Mode 無效。若某個 Mode 裡一個 item 都沒有,RunLoop 會直接退出,不進入循環。

RunLoop 的 Mode

struct __CFRunLoopMode {
    CFStringRef _name;            // Mode Name,例如 @"kCFRunLoopDefaultMode"
    CFMutableSetRef _sources0;    // Set
    CFMutableSetRef _sources1;    // Set
    CFMutableArrayRef _observers; // Array
    CFMutableArrayRef _timers;    // Array
    ...
};

struct __CFRunLoop {
    CFMutableSetRef _commonModes;      // Set
    CFMutableSetRef _commonModeItems;  // Set
    CFRunLoopModeRef _currentMode;     // Current Runloop Mode
    CFMutableSetRef _modes;            // Set
    ...
};

這裡有個關鍵概念叫「CommonModes」:一個 Mode 可以通過把它的 ModeName 加入 RunLoop 的 commonModes 而獲得「Common」屬性。每當 RunLoop 內容發生變化,_commonModeItems 裡的 Source/Observer/Timer 都會自動同步到所有帶 Common 標記的 Mode。

典型場景:主線程 RunLoop 有兩個預置 Mode——kCFRunLoopDefaultMode(App 日常狀態)和 UITrackingRunLoopMode(追蹤 ScrollView 滑動),二者都已標記為 Common。當你把一個 Timer 加到 DefaultMode,平時能正常回調;一旦滑動 TableView,RunLoop 切換到 TrackingRunLoopMode,Timer 就不再回調,也不會卡住滑動。

若希望 Timer 在兩個 Mode 下都能回調,可以分別加入兩個 Mode,也可以直接加入頂層 RunLoop 的 commonModeItems,讓它自動分發到所有 Common Mode。

對外暴露的 Mode 管理接口只有兩個:

CFRunLoopAddCommonMode(CFRunLoopRef runloop, CFStringRef modeName);
CFRunLoopRunInMode(CFStringRef modeName, ...);

Mode 上管理 mode item 的接口則有:

CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef modeName);
CFRunLoopAddObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef modeName);
CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);
CFRunLoopRemoveSource(...);
CFRunLoopRemoveObserver(...);
CFRunLoopRemoveTimer(...);

你只能通過 mode name 操作內部 Mode;傳入一個不存在的新 name 時,RunLoop 會自動創建。對一個 RunLoop 而言,內部 Mode 只能增不能刪。

蘋果公開的 Mode 有 kCFRunLoopDefaultMode(NSDefaultRunLoopMode)和 UITrackingRunLoopMode;另外還提供了一個操作 Common 標記的字符串 kCFRunLoopCommonModes(NSRunLoopCommonModes),使用時注意與其他 mode name 區分。

RunLoop 的內部邏輯

按蘋果文檔的說明,內部流程大致如下圖。

整理後的僞代碼如下(篇幅所限做了濃縮):

/// 用 DefaultMode 啟動
void CFRunLoopRun(void) {
    CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
}

/// RunLoop 的實現(簡化)
int CFRunLoopRunSpecific(runloop, modeName, seconds, stopAfterHandle) {

    /// 根據 modeName 找到對應 mode
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(runloop, modeName, false);
    /// 如果 mode 裡沒有 source/timer/observer,直接返回
    if (__CFRunLoopModeIsEmpty(currentMode)) return;

    /// 1. 通知 Observers:即將進入 loop
    __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopEntry);

    do {
        /// 2. 通知 Observers:即將觸發 Timer 回調
        __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeTimers);
        /// 3. 通知 Observers:即將觸發 Source0 回調
        __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeSources);
        /// 執行被加入的 block
        __CFRunLoopDoBlocks(runloop, currentMode);

        /// 4. 觸發 Source0(非 port)回調
        sourceHandledThisLoop = __CFRunLoopDoSources0(runloop, currentMode, stopAfterHandle);
        __CFRunLoopDoBlocks(runloop, currentMode);

        /// 5. 若有基於 port 的 Source1 處於 ready 狀態,直接處理並跳去 handle_msg
        if (__Source0DidDispatchPortLastTime) {
            Boolean hasMsg = __CFRunLoopServiceMachPort(dispatchPort, &msg)
            if (hasMsg) goto handle_msg;
        }

        /// 6. 通知 Observers:線程即將休眠
        if (!sourceHandledThisLoop) {
            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeWaiting);
        }

        /// 7. 調用 mach_msg 等待 mach_port 消息,線程進入休眠
        ///    喚醒條件:Source1 事件 / Timer 到點 / RunLoop 超時 / 被手動喚醒
        __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort) {
            mach_msg(msg, MACH_RCV_MSG, port); // thread wait for receive msg
        }

        /// 8. 通知 Observers:線程剛被喚醒
        __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopAfterWaiting);

        handle_msg:
        /// 9.1 Timer 到點,觸發 Timer 回調
        if (msg_is_timer) {
            __CFRunLoopDoTimers(runloop, currentMode, mach_absolute_time())
        }
        /// 9.2 有 dispatch 到 main_queue 的 block,執行 block
        else if (msg_is_dispatch) {
            __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
        }
        /// 9.3 Source1 發出事件,處理該事件
        else {
            CFRunLoopSourceRef source1 = __CFRunLoopModeFindSourceForMachPort(runloop, currentMode, livePort);
            sourceHandledThisLoop = __CFRunLoopDoSource1(runloop, currentMode, source1, msg);
            if (sourceHandledThisLoop) {
                mach_msg(reply, MACH_SEND_MSG, reply);
            }
        }

        __CFRunLoopDoBlocks(runloop, currentMode);

        if (sourceHandledThisLoop && stopAfterHandle) {
            retVal = kCFRunLoopRunHandledSource;   // 處理完事件就返回
        } else if (timeout) {
            retVal = kCFRunLoopRunTimedOut;        // 超時
        } else if (__CFRunLoopIsStopped(runloop)) {
            retVal = kCFRunLoopRunStopped;         // 被外部強制停止
        } else if (__CFRunLoopModeIsEmpty(runloop, currentMode)) {
            retVal = kCFRunLoopRunFinished;        // source/timer/observer 都沒有了
        }
    } while (retVal == 0);

    /// 10. 通知 Observers:即將退出
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
}

可見 RunLoop 就是這樣一個函數:內部是一個 do-while 循環。調用 CFRunLoopRun() 後線程會一直停留在循環裡,直到超時或被手動停止才返回。

RunLoop 的底層實現

核心是基於 mach port 的,休眠時調用的是 mach_msg()。要理解這一切,先看一眼系統架構。

蘋果把系統大致分為四層:應用層(Spotlight、Aqua、SpringBoard 等)、應用框架層(Cocoa 等)、核心框架層(各類核心框架、OpenGL)、以及 Darwin——操作系統核心,包含內核、驅動、Shell,這一層源碼開放。

再往下看 Darwin:硬件之上的 Mach、BSD、IOKit 共同組成 XNU 內核。Mach 作為微內核,只提供處理器調度、IPC 等極少量基礎服務;BSD 是圍繞 Mach 的外環,提供進程管理、文件系統、網絡等能力;IOKit 則為設備驅動提供 C++ 面向對象框架。

Mach 提供的 API 非常有限,蘋果也不鼓勵直接使用,但沒有它們什麼都做不成。在 Mach 中一切皆「對象」——進程、線程、虛擬內存都是對象,且對象之間不能直接調用,只能通過消息在端口(port)之間傳遞,這就是 Mach IPC 的核心。

typedef struct {
    mach_msg_header_t header;
    mach_msg_body_t   body;
} mach_msg_base_t;

typedef struct {
    mach_msg_bits_t       msgh_bits;
    mach_msg_size_t       msgh_size;
    mach_port_t           msgh_remote_port;
    mach_port_t           msgh_local_port;
    mach_port_name_t      msgh_voucher_port;
    mach_msg_id_t         msgh_id;
} mach_msg_header_t;

一條 Mach 消息本質上就是一個二進制數據包,頭部標明了本地端口與目標端口。發送與接收用同一個 API,靠 option 標記方向:

mach_msg_return_t mach_msg(mach_msg_header_t *msg, mach_msg_option_t option,
                           mach_msg_size_t send_size, mach_msg_size_t rcv_size,
                           mach_port_name_t rcv_name, mach_msg_timeout_t timeout,
                           mach_port_name_t notify);

mach_msg() 內部實際調用的是 mach_msg_trap()——Mach 中的 trap 等同於系統調用。用戶態調用 mach_msg_trap() 會觸發陷阱機制切換到內核態,由內核中的 mach_msg() 完成實際工作。

所以 RunLoop 的核心就是一個 mach_msg():調用它去接收消息,若沒有人發送 port 消息,內核就把線程置於等待狀態。你可以在模擬器裡跑起一個 App,靜止時點暫停,會看到主線程調用棧正停在 mach_msg_trap()。

蘋果用 RunLoop 實現了什麼

App 啟動後 RunLoop 的狀態大致如下(節選):

CFRunLoop {
    current mode = kCFRunLoopDefaultMode
    common modes = {
        UITrackingRunLoopMode
        kCFRunLoopDefaultMode
    }

    common mode items = {
        // source0 (manual)
        CFRunLoopSource {order = -1, { callout = _UIApplicationHandleEventQueue}}
        CFRunLoopSource {order = -1, { callout = PurpleEventSignalCallback }}

        // source1 (mach port)
        CFRunLoopSource {order = 0, {port = 17923}}
        CFRunLoopSource {order = -1, { callout = PurpleEventCallback}}

        // Observer
        CFRunLoopObserver {order = -2147483647, activities = 0x1,   // Entry
            callout = _wrapRunLoopWithAutoreleasePoolHandler}
        CFRunLoopObserver {order = 0, activities = 0x20,           // BeforeWaiting
            callout = _UIGestureRecognizerUpdateObserver}
        CFRunLoopObserver {order = 1999000, activities = 0xa0,     // BeforeWaiting | Exit
            callout = _afterCACommitHandler}
        CFRunLoopObserver {order = 2000000, activities = 0xa0,
            callout = _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv}
        CFRunLoopObserver {order = 2147483647, activities = 0xa0,
            callout = _wrapRunLoopWithAutoreleasePoolHandler}

        // Timer
        CFRunLoopTimer {callout = _ZN2CAL14timer_callbackEP16__CFRunLoopTimerPv (QuartzCore.framework)}
    }

    modes = { /* kCFRunLoopDefaultMode、UITrackingRunLoopMode 等 */ }
}

系統預設注冊了 5 個 Mode:

  1. kCFRunLoopDefaultMode:App 默認 Mode,主線程通常運行於此。
  2. UITrackingRunLoopMode:界面跟蹤 Mode,用於 ScrollView 追蹤觸摸滑動。
  3. UIInitializationRunLoopMode:App 剛啟動時進入的第一個 Mode,啟動完成後不再使用。
  4. GSEventReceiveRunLoopMode:接收系統事件的內部 Mode,通常用不到。
  5. kCFRunLoopCommonModes:佔位用,沒有實際作用。

RunLoop 回調時一般都是通過一個很長的函數 call out 出去。調試時若在調用棧上看到這些長名字,可以對照下面的整理版定位:

{
    /// 1. 通知 Observers,即將進入 RunLoop
    ///    此處 Observer 會創建 AutoreleasePool: _objc_autoreleasePoolPush();
    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopEntry);
    do {
        /// 2. 即將觸發 Timer 回調
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeTimers);
        /// 3. 即將觸發 Source0 回調
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeSources);
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);

        /// 4. 觸發 Source0 回調
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__(source0);
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);

        /// 6. 即將進入休眠
        ///    此處 Observer 釋放並新建 AutoreleasePool
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeWaiting);

        /// 7. sleep to wait msg
        mach_msg() -> mach_msg_trap();

        /// 8. 通知 Observers,線程被喚醒
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopAfterWaiting);

        /// 9. 被 Timer 喚醒,回調 Timer
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(timer);
        /// 9. 被 dispatch 喚醒,執行 main queue 中的 block
        __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(dispatched_block);
        /// 9. 被 Source1 喚醒,處理該事件
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__(source1);
    } while (...);

    /// 10. 即將退出 RunLoop,此處 Observer 釋放 AutoreleasePool
    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopExit);
}

AutoreleasePool

App 啟動後,蘋果在主線程 RunLoop 注冊了兩個 Observer,回調都是 _wrapRunLoopWithAutoreleasePoolHandler()。第一個監測 Entry,回調中調用 _objc_autoreleasePoolPush() 創建釋放池,order 為 -2147483647,優先級最高,確保池子在其他回調之前建好。第二個監測 BeforeWaiting(釋放舊池並新建)與 Exit(釋放池),order 為 2147483647,優先級最低,確保釋放發生在所有回調之後。

因此主線程上的代碼——事件回調、Timer 回調等——都被 RunLoop 建好的 AutoreleasePool 環繞,不會洩漏,也不必手動建池。

事件響應

蘋果注冊了一個基於 mach port 的 Source1 接收系統事件,回調為 __IOHIDEventSystemClientQueueCallback()。硬件事件(觸摸、鎖屏、搖晃等)發生後,先由 IOKit.framework 生成 IOHIDEvent 交給 SpringBoard;SpringBoard 只接收按鍵、觸摸、加速、接近傳感器等幾類事件,再用 mach port 轉發給目標 App 進程。隨後該 Source1 觸發回調,調用 _UIApplicationHandleEventQueue() 在應用內部分發。

_UIApplicationHandleEventQueue() 會把 IOHIDEvent 包裝成 UIEvent,完成手勢識別、屏幕旋轉處理、分發給 UIWindow 等工作。UIButton 點擊、touchesBegin/Move/End/Cancel 都是在這個回調裡完成的。

手勢識別

當 _UIApplicationHandleEventQueue() 識別到一個手勢,會先調用 Cancel 打斷當前的 touches 系列回調,再把對應的 UIGestureRecognizer 標記為待處理。蘋果注冊的 Observer 監測 BeforeWaiting,回調 _UIGestureRecognizerUpdateObserver() 會取出所有待處理的識別器並執行其回調。識別器有創建、銷毀、狀態改變時,這條鏈路都會被觸發。

界面更新

當你修改 Frame、調整 UIView/CALayer 層次,或調用 setNeedsLayout/setNeedsDisplay 後,該對象會被標記為待處理並提交到一個全局容器。蘋果注冊的 Observer 監聽 BeforeWaiting 與 Exit,回調 _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv(),在其中遍歷待處理對象執行真正的繪制與布局。

_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv()
    QuartzCore:CA::Transaction::observer_callback:
        CA::Transaction::commit();
            CA::Context::commit_transaction();
                CA::Layer::layout_and_display_if_needed();
                    CA::Layer::layout_if_needed();
                        [CALayer layoutSublayers];
                            [UIView layoutSubviews];
                    CA::Layer::display_if_needed();
                        [CALayer display];
                            [UIView drawRect];

定時器

NSTimer 就是 CFRunLoopTimerRef,兩者 toll-free bridged。Timer 注冊後,RunLoop 會為它重復的時間點排好事件。為節省資源,RunLoop 並不會在精確時刻回調,而是允許一定誤差,這個容許範圍由 Tolerance 屬性決定。

如果某個時間點被錯過(例如主線程忙於長任務),該次回調會直接跳過,不會補執行。就像等公交:錯過 10:10 那趟,只能等 10:20。

CADisplayLink 則是與屏幕刷新率同步的定時器(實現原理更複雜,內部操作的是一個 Source)。若兩次刷新之間執行了長任務,就會丟一幀,造成卡頓感。快速滑動 TableView 時,哪怕一幀卡頓用戶也能察覺——Facebook 開源的 AsyncDisplayKit 正是為了解決這個問題,其內部同樣用到了 RunLoop。

PerformSelecter

調用 performSelecter:afterDelay: 時,內部會創建一個 Timer 加入當前線程的 RunLoop,因此當前線程若沒有 RunLoop,該方法就失效。performSelector:onThread: 同理,目標線程沒有 RunLoop 也不會生效。

關於 GCD

RunLoop 底層也用到了 GCD,例如它的 Timer 是用 dispatch_source_t 實現的;反過來,GCD 的某些接口也依賴 RunLoop。調用 dispatch_async(dispatch_get_main_queue(), block) 時,libDispatch 會向主線程 RunLoop 發送消息喚醒它,RunLoop 取出 block 並在 __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__() 中執行。注意這套邏輯只適用於主線程,dispatch 到其他線程仍由 libDispatch 自己處理。

關於網絡請求

iOS 的網絡接口自下而上分為幾層:

CFSocket
CFNetwork                       -> ASIHttpRequest
NSURLConnection                 -> AFNetworking
NSURLSession                    -> AFNetworking2, Alamofire
  • CFSocket:最底層,只負責 socket 通信。
  • CFNetwork:基於 CFSocket 的上層封裝,ASIHttpRequest 工作於此。
  • NSURLConnection:更高層的面向對象封裝,AFNetworking 工作於此。
  • NSURLSession:iOS 7 新增,表面與 NSURLConnection 並列,底層仍用到部分 NSURLConnection 能力(如 com.apple.NSURLConnectionLoader 線程),AFNetworking2 與 Alamofire 工作於此。

以 NSURLConnection 為例:調用 [connection start] 後,內部會獲取 CurrentRunLoop,並在 DefaultMode 中添加 4 個 Source0(需手動觸發),其中 CFMultiplexerSource 負責各類 Delegate 回調,CFHTTPCookieStorage 處理 Cookie。

開始傳輸時會新建兩個線程:com.apple.NSURLConnectionLoader 與 com.apple.CFSocket.private。CFSocket 線程處理底層 socket 連接;NSURLConnectionLoader 內部用 RunLoop 接收底層 socket 事件,再通過之前添加的 Source0 通知上層 Delegate。

NSURLConnectionLoader 的 RunLoop 通過基於 mach port 的 Source 接收 CFSocket 通知,再在合適時機向 CFMultiplexerSource 等 Source0 發消息,同時喚醒 Delegate 線程的 RunLoop 執行實際回調。

實際應用舉例

AFNetworking

AFURLConnectionOperation 基於 NSURLConnection 構建,希望能在後台線程接收 Delegate 回調。為此它單獨創建了一個線程並在其中啟動 RunLoop:

+ (void)networkRequestThreadEntryPoint:(id)__unused object {
    @autoreleasepool {
        [[NSThread currentThread] setName:@"AFNetworking"];
        NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
        [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
        [runLoop run];
    }
}

+ (NSThread *)networkRequestThread {
    static NSThread *_networkRequestThread = nil;
    static dispatch_once_t oncePredicate;
    dispatch_once(&oncePredicate, ^{
        _networkRequestThread = [[NSThread alloc] initWithTarget:self selector:@selector(networkRequestThreadEntryPoint:) object:nil];
        [_networkRequestThread start];
    });
    return _networkRequestThread;
}

RunLoop 啟動前內部必須至少有一個 Timer/Observer/Source,所以 AFNetworking 在 [runLoop run] 之前先添加了一個 NSMachPort——目的僅是讓 RunLoop 不至於立刻退出,並不用於實際發消息。

- (void)start {
    [self.lock lock];
    if ([self isCancelled]) {
        [self performSelector:@selector(cancelConnection) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
    } else if ([self isReady]) {
        self.state = AFOperationExecutingState;
        [self performSelector:@selector(operationDidStart) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
    }
    [self.lock unlock];
}

需要後台線程幹活時,AFNetworking 通過 performSelector:onThread: 把任務丟進該線程的 RunLoop。

AsyncDisplayKit

ASDK 是 Facebook 為保持界面流暢而做的框架。UI 線程上的繁重任務通常分三類:排版(計算視圖大小、文本高度、重新排版子視圖)、繪制(CoreText 文本繪制、圖片解壓、Quartz 元素繪制)、UI 對象操作(UIView/CALayer 的創建、屬性設置、銷毀)。

前兩類可以扔到後台線程,最後一類只能在主線程完成,且有時還依賴前面的計算結果。ASDK 的策略是:能放後台的盡量放後台,不能的盡量推遲(例如視圖創建、屬性調整)。

為此它實現了 ASDisplayNode,內部封裝 UIView/CALayer 並提供 frame、backgroundColor 等相似屬性,這些屬性都可以在後台線程修改;開發者只操作 Node,排版與繪制自然就能移到後台。但無論如何,這些屬性最終都要同步到主線程的 UIView/CALayer。

ASDK 仿照 QuartzCore/UIKit 的做法,在主線程 RunLoop 中添加一個 Observer,監聽 kCFRunLoopBeforeWaiting 與 kCFRunLoopExit,收到回調時遍歷隊列中所有待處理任務並逐一執行。具體實現可參考 _ASAsyncTransactionGroup。

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