
RunLoop 是 iOS 與 OS X 開發中極基礎卻又常被忽略的概念。本文從 CFRunLoop 源碼出發,講清 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 工程慢慢看。
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 在第一次獲取時創建,在線程結束時銷毀。你也只能在自己的線程內部獲取它(主線程除外)。
CoreFoundation 裡與 RunLoop 相關的有 5 個類:CFRunLoopRef、CFRunLoopModeRef、CFRunLoopSourceRef、CFRunLoopTimerRef、CFRunLoopObserverRef。其中 CFRunLoopModeRef 並未直接對外暴露,只通過 CFRunLoopRef 的接口間接操作。

一個 RunLoop 包含若干 Mode,每個 Mode 又包含若干 Source/Timer/Observer。調用 RunLoop 主函數時只能指定其中一個 Mode(CurrentMode),需要切換只能退出 Loop 再重新進入。這樣做是為了隔離不同組的 Source/Timer/Observer,互不干擾。
CFRunLoopSourceRef 是事件產生的源頭,分兩版:
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 會直接退出,不進入循環。
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 區分。
按蘋果文檔的說明,內部流程大致如下圖。

整理後的僞代碼如下(篇幅所限做了濃縮):
/// 用 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() 後線程會一直停留在循環裡,直到超時或被手動停止才返回。
核心是基於 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()。
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:
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);
}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:afterDelay: 時,內部會創建一個 Timer 加入當前線程的 RunLoop,因此當前線程若沒有 RunLoop,該方法就失效。performSelector:onThread: 同理,目標線程沒有 RunLoop 也不會生效。
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
以 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。