注：以Core Foundation的實現(xiàn)作為參考（版本為CF-855.17）。
1. 相關數(shù)據(jù)結構
1.1 run loop的基本結構
CFRunLoopRef，是__CFRunLoop的結構體指針：
typedef struct __CFRunLoop * CFRunLoopRef;
struct __CFRunLoop {
CFRuntimeBase _base; // CF對象類型，相當于OC對象的isa
pthread_mutex_t _lock; // 訪問mode列表時保證同步
__CFPort _wakeUpPort; // 線程被喚醒時使用
Boolean _unused;
volatile _per_run_data *_perRunData; // 每次運行的相關狀態(tài)數(shù)據(jù)
pthread_t _pthread; // 綁定的線程
uint32_t _winthread;
// 標記為“common”的mode的名稱組成的集合
CFMutableSetRef _commonModes;
// “common”的mode對應的統(tǒng)一item的集合
CFMutableSetRef _commonModeItems;
// runloop當前所處的mode
CFRunLoopModeRef _currentMode;
// 所有的mode的集合
CFMutableSetRef _modes;
struct _block_item *_blocks_head;
struct _block_item *_blocks_tail;
CFTypeRef _counterpart;
};
作為RunLoop的基本數(shù)據(jù)結構，CFRunLoopRef內(nèi)部主要包含了：
- _commonModes：標記為“common”的mode的集合
- _commonModeItems：所有“common”mode中共享的item，即修改此內(nèi)部的item，就會對所有的“common”的mode內(nèi)部的item進行更新。
- _currentMode：當前所在的mode模式，切換時要退出重新指定
- _modes：所有支持的mode。
常用API：
// 獲取當前線程的run loop（延遲加載，不訪問不創(chuàng)建）
CF_EXPORT CFRunLoopRef CFRunLoopGetCurrent(void);
// 獲取主線程的run loop（APP啟動后自動創(chuàng)建并運行）
CF_EXPORT CFRunLoopRef CFRunLoopGetMain(void);
既然引入了mode這一概念，我們就看看mode到底是個啥。
1.2 RunLoop的Mode
RunLoop的mode為內(nèi)部數(shù)據(jù)，沒有對外公開。類型為CFRunLoopModeRef，即__CFRunLoopMode的結構體指針。看一下簡化過的代碼結構：
typedef struct __CFRunLoopMode *CFRunLoopModeRef;
struct __CFRunLoopMode {
CFRuntimeBase _base;
pthread_mutex_t _lock; // 在對mode加鎖之前必須持有了run loop的鎖
CFStringRef _name; // mode名稱，區(qū)分mode使用
Boolean _stopped;
char _padding[3];
CFMutableSetRef _sources0;
CFMutableSetRef _sources1;
CFMutableArrayRef _observers;
CFMutableArrayRef _timers;
CFMutableDictionaryRef _portToV1SourceMap;
__CFPortSet _portSet;
CFIndex _observerMask;
mach_port_t _timerPort;
Boolean _mkTimerArmed;
uint64_t _timerSoftDeadline; /* TSR */
uint64_t _timerHardDeadline; /* TSR */
};
其中，CFRunLoopModeRef中主要包含了如下幾個內(nèi)容：
- _name：用于識別區(qū)分不同的mode實例。切換mode時可以使用。
- _sources0：非基于端口的源的集合（我們在線程中自己添加的一般都是source0）
- _sources1：基于端口的源的集合（通過Mach Port進行線程間通信使用）
- _observers：觀察者的數(shù)組，用于runloop在不同狀態(tài)時發(fā)送通知的接收對象。
- _timers：定時器數(shù)組，包含的就是NSTimer對象。
常用API：
// 啟動run loop
CF_EXPORT void CFRunLoopRun(void);
// 以指定mode的方式啟動run loop
CF_EXPORT SInt32 CFRunLoopRunInMode(CFStringRef mode, CFTimeInterval seconds, Boolean returnAfterSourceHandled);
// 將指定mode加入到run loop的commonMode數(shù)組中（加入的是modeName）
CF_EXPORT void CFRunLoopAddCommonMode(CFRunLoopRef rl, CFStringRef mode);
下面我們分著來看各部分的數(shù)據(jù)結構。
1.3 RunLoop源
CFRunLoopSourceRef，即__CFRunLoopSource結構體的指針。其基本結構如下：
typedef struct __CFRunLoopSource * CFRunLoopSourceRef;
struct __CFRunLoopSource {
CFRuntimeBase _base;
uint32_t _bits;
pthread_mutex_t _lock;
CFIndex _order; // 優(yōu)先級，不可變
CFMutableBagRef _runLoops; // 綁定的runloop對象
union {
CFRunLoopSourceContext version0; /* immutable, except invalidation */
CFRunLoopSourceContext1 version1; /* immutable, except invalidation */
} _context;
};
其中，聯(lián)合體中的成員version0和version1即為上面mode中的source0和source1。大概看一下二者的結構體：
typedef struct {
CFIndex version;
void * info;
const void *(*retain)(const void *info);
void (*release)(const void *info);
CFStringRef (*copyDescription)(const void *info);
Boolean (*equal)(const void *info1, const void *info2);
CFHashCode (*hash)(const void *info);
void (*schedule)(void *info, CFRunLoopRef rl, CFStringRef mode);
void (*cancel)(void *info, CFRunLoopRef rl, CFStringRef mode);
void (*perform)(void *info);
} CFRunLoopSourceContext;
typedef struct {
CFIndex version;
void * info;
const void *(*retain)(const void *info);
void (*release)(const void *info);
CFStringRef (*copyDescription)(const void *info);
Boolean (*equal)(const void *info1, const void *info2);
CFHashCode (*hash)(const void *info);
#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)
mach_port_t (*getPort)(void *info);
void * (*perform)(void *msg, CFIndex size, CFAllocatorRef allocator, void *info);
#else
void * (*getPort)(void *info);
void (*perform)(void *info);
#endif
} CFRunLoopSourceContext1;
可以看到，二者內(nèi)容基本相同，都是包含了內(nèi)存管理、相等性、hash等信息。不同的是source1的結構體（CFRunLoopSourceContext1）包含了mach_port相關函數(shù)。
因此，可以將source根據(jù)類型（version成員的0和1）分為source0和source1。
常用API：
// 創(chuàng)建source（傳入不同類型的context即可得到source0或source1）
CF_EXPORT CFRunLoopSourceRef CFRunLoopSourceCreate(CFAllocatorRef allocator, CFIndex order, CFRunLoopSourceContext *context);
// 向run loop的指定mode中添加source
CF_EXPORT void CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef mode);
// 從run loop的指定mode中移除source
CF_EXPORT void CFRunLoopRemoveSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef mode);
1.4 Run Loop的定時器
定時器為CFRunLoopTimerRef類型，也就是__CFRunLoopTimer的結構體指針。
typedef struct __CFRunLoopTimer * CFRunLoopTimerRef;
struct __CFRunLoopTimer {
CFRuntimeBase _base;
uint16_t _bits;
pthread_mutex_t _lock;
CFRunLoopRef _runLoop; // 綁定的run loop
CFMutableSetRef _rlModes;
CFAbsoluteTime _nextFireDate; // 下次觸發(fā)時間
CFTimeInterval _interval; // 時間間隔
CFTimeInterval _tolerance; // 寬容度
uint64_t _fireTSR; /* TSR units */
CFIndex _order; /* immutable */
CFRunLoopTimerCallBack _callout; // 回調(diào)
CFRunLoopTimerContext _context; /* immutable, except invalidation */
};
其中，主要包含了：
- _runLoop：綁定到的run loop
- _interval：執(zhí)行事件間隔（重復執(zhí)行的定時器）
- _tolerance：寬容度，也就是指定執(zhí)行時間的最大延遲時間
- _callout：執(zhí)行的回調(diào)函數(shù)指針
- _context：定時器上下文對象，包含內(nèi)存管理等相關函數(shù)
typedef struct {
CFIndex version;
void * info;
const void *(*retain)(const void *info);
void (*release)(const void *info);
CFStringRef (*copyDescription)(const void *info);
} CFRunLoopTimerContext;
typedef void (*CFRunLoopTimerCallBack)(CFRunLoopTimerRef timer, void *info);
常用API:
// 以callback回調(diào)函數(shù)指針的形式創(chuàng)建timer
CF_EXPORT CFRunLoopTimerRef CFRunLoopTimerCreate(CFAllocatorRef allocator, CFAbsoluteTime fireDate, CFTimeInterval interval, CFOptionFlags flags, CFIndex order, CFRunLoopTimerCallBack callout, CFRunLoopTimerContext *context);
// 以block的形式創(chuàng)建timer
CF_EXPORT CFRunLoopTimerRef CFRunLoopTimerCreateWithHandler(CFAllocatorRef allocator, CFAbsoluteTime fireDate, CFTimeInterval interval, CFOptionFlags flags, CFIndex order, void (^block) (CFRunLoopTimerRef timer)) CF_AVAILABLE(10_7, 5_0);
// 向run loop的指定mode中添加timer
CF_EXPORT void CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);
// 從run loop的指定mode中移除timer
CF_EXPORT void CFRunLoopRemoveTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);
1.5 Run Loop的觀察者
觀察者為CFRunLoopObserverRef類型，即__CFRunLoopObserver的結構體指針。
typedef struct __CFRunLoopObserver * CFRunLoopObserverRef;
struct __CFRunLoopObserver {
CFRuntimeBase _base;
pthread_mutex_t _lock;
CFRunLoopRef _runLoop;
CFIndex _rlCount;
CFOptionFlags _activities; /* immutable */
CFIndex _order; /* immutable */
CFRunLoopObserverCallBack _callout; /* immutable */
CFRunLoopObserverContext _context; /* immutable, except invalidation */
};
其中，主要包含：
- _runLoop：對應的run loop
- _activities：用于監(jiān)聽的run loop的指定運行狀態(tài)。
- _order：優(yōu)先級
- _callout：收到監(jiān)聽通知的回調(diào)函數(shù)指針。
- _context：上下文對象
activities，即CFOptionFlags，用于識別run loop在不同執(zhí)行時刻的運行狀態(tài)：
/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
/** 進入loop */
kCFRunLoopEntry = (1UL << 0),
/** 準備執(zhí)行timer */
kCFRunLoopBeforeTimers = (1UL << 1),
/** 準備執(zhí)行source */
kCFRunLoopBeforeSources = (1UL << 2),
/** 線程準備進入休眠 */
kCFRunLoopBeforeWaiting = (1UL << 5),
/** 線程剛被喚醒，還沒有進行任務處理 */
kCFRunLoopAfterWaiting = (1UL << 6),
/** 退出loop */
kCFRunLoopExit = (1UL << 7),
/** 所有的狀態(tài) */
kCFRunLoopAllActivities = 0x0FFFFFFFU
};
上下文對象為CFRunLoopObserverContext結構體，內(nèi)部包含了內(nèi)存管理的相關函數(shù)指針：
typedef struct {
CFIndex version;
void * info;
const void *(*retain)(const void *info);
void (*release)(const void *info);
CFStringRef (*copyDescription)(const void *info);
} CFRunLoopObserverContext;
回調(diào)函數(shù)的類型為：
typedef void (*CFRunLoopObserverCallBack)(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info);
常用API：
// 創(chuàng)建新的run loop觀察者，使用callback回調(diào)函數(shù)指針的方式
CF_EXPORT CFRunLoopObserverRef CFRunLoopObserverCreate(CFAllocatorRef allocator, CFOptionFlags activities, Boolean repeats, CFIndex order, CFRunLoopObserverCallBack callout, CFRunLoopObserverContext *context);
// 創(chuàng)建新的run loop觀察者，使用block的方式
CF_EXPORT CFRunLoopObserverRef CFRunLoopObserverCreateWithHandler(CFAllocatorRef allocator, CFOptionFlags activities, Boolean repeats, CFIndex order, void (^block) (CFRunLoopObserverRef observer, CFRunLoopActivity activity)) CF_AVAILABLE(10_7, 5_0);
// 向run loop的指定mode中添加觀察者
CF_EXPORT void CFRunLoopAddObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef mode);
// 從run loop的指定mode中移除觀察者
CF_EXPORT void CFRunLoopRemoveObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef mode);
2. 重點API基本實現(xiàn)
2.1 CFRunLoopGetMain & CFRunLoopGetCurrent
系統(tǒng)隱藏了生成過程，通過獲取線程對應的runloop對象，即可完成創(chuàng)建。
// 獲取主線程的runloop
CFRunLoopRef CFRunLoopGetMain(void) {
CHECK_FOR_FORK();
static CFRunLoopRef __main = NULL; // no retain needed
if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // no CAS needed
return __main;
}
// 獲取當前線程的runloop
CFRunLoopRef CFRunLoopGetCurrent(void) {
CHECK_FOR_FORK();
CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
if (rl) return rl;
return _CFRunLoopGet0(pthread_self());
}
可以看到，真正的實現(xiàn)都在 _CFRunLoopGet0 函數(shù)中：
static CFMutableDictionaryRef __CFRunLoops = NULL;
static CFSpinLock_t loopsLock = CFSpinLockInit;
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
// t為0，即為主線程
if (pthread_equal(t, kNilPthreadT)) {
t = pthread_main_thread_np();
}
// 獲取鎖
__CFSpinLock(&loopsLock);
// 懶加載，第一次調(diào)用為主線程，創(chuàng)建全局字典，并將新創(chuàng)建的主線程runloop加入其中
if (!__CFRunLoops) {
// 釋放鎖
__CFSpinUnlock(&loopsLock);
// 創(chuàng)建字典容器，用于存儲runloop
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
// 創(chuàng)建主線程的runloop
CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
// 插入到字典中（key為線程指針）
CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
// __CFRunLoops全局字典指針指向此字典容器
if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
CFRelease(dict);
}
CFRelease(mainLoop);
// 再次獲取鎖
__CFSpinLock(&loopsLock);
}
// 從全局字典容器中獲取指定runloop
CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
// 釋放鎖
__CFSpinUnlock(&loopsLock);
// 懶加載
if (!loop) {
// 創(chuàng)建新runloop
CFRunLoopRef newLoop = __CFRunLoopCreate(t);
__CFSpinLock(&loopsLock);
loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
if (!loop) {
// 在全局字典容器中插入runloop
CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
loop = newLoop;
}
__CFSpinUnlock(&loopsLock);
CFRelease(newLoop);
}
if (pthread_equal(t, pthread_self())) {
_CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
}
}
return loop;
}
通過實現(xiàn)可以看到：
- runloop對象整體懶加載，不調(diào)用不生成。
- runloop對象保存在全局字典中，key為線程指針。
- 系統(tǒng)第一次調(diào)用時，生成全局字典，且自動創(chuàng)建主線程的runloop，插入其中，因此APP可以保持運行。
2.2 CFRunLoopRun
首先看一下run loop的啟動過程：
void CFRunLoopRun(void) { /* DOES CALLOUT */
int32_t result;
do {
result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
CHECK_FOR_FORK();
} while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}
SInt32 CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) { /* DOES CALLOUT */
CHECK_FOR_FORK();
return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}
在以上兩個啟動run loop的函數(shù)中，真正的實現(xiàn)都包含在CFRunLoopRunSpecific中，且此函數(shù)會返回run loop的執(zhí)行狀態(tài)（由CFRunLoopRunInMode()函數(shù)返回）。
enum {
kCFRunLoopRunFinished = 1,
kCFRunLoopRunStopped = 2,
kCFRunLoopRunTimedOut = 3,
kCFRunLoopRunHandledSource = 4
};
現(xiàn)在，我們看一下運行循環(huán)，到底是如何循環(huán)的。
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) { /* DOES CALLOUT */
CHECK_FOR_FORK();
// 正在釋放，直接返回
if (__CFRunLoopIsDeallocating(rl)) return kCFRunLoopRunFinished;
// run loop獲取鎖
__CFRunLoopLock(rl);
// 根據(jù)指定modeName，獲取到mode對象
CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
// 若不存在此mode，或內(nèi)部沒有mode item
if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
// 返回
Boolean did = false;
if (currentMode) __CFRunLoopModeUnlock(currentMode);
__CFRunLoopUnlock(rl);
return did ? kCFRunLoopRunHandledSource : kCFRunLoopRunFinished;
}
// 設置新的perRunData，返回舊值
volatile _per_run_data *previousPerRun = __CFRunLoopPushPerRunData(rl);
// 之前所處的mode
CFRunLoopModeRef previousMode = rl->_currentMode;
// 記錄為新的運行mode
rl->_currentMode = currentMode;
// 設置為已完成，待返回
int32_t result = kCFRunLoopRunFinished;
// 如果存在監(jiān)聽進入loop狀態(tài)的觀察者
if (currentMode->_observerMask & kCFRunLoopEntry )
// 通知觀察者，run loop已進入（新mode進入）
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
// ** 核心：切換運行新mode（循環(huán)在這里面實現(xiàn)） **
result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
// 如果存在監(jiān)聽退出loop狀態(tài)的觀察者
if (currentMode->_observerMask & kCFRunLoopExit )
// 通知觀察者，run loop已退出
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
// 釋放mode的鎖
__CFRunLoopModeUnlock(currentMode);
// 恢復為原始的perRunData，恢復狀態(tài)
__CFRunLoopPopPerRunData(rl, previousPerRun);
// run loop的運行mode恢復為原mode
rl->_currentMode = previousMode;
// 釋放run loop自身的鎖
__CFRunLoopUnlock(rl);
return result;
}
CFRunLoopRunSpecific函數(shù)的整體運行，是一個“創(chuàng)建新現(xiàn)場 -- 執(zhí)行l(wèi)oop -- 恢復舊現(xiàn)場”的過程。
- 根據(jù)指定的modeName名稱，獲取run loop內(nèi)部保存的mode對象。將其設置為currentMode，然后創(chuàng)建新的perRunData進行設置。且如果存在進入循環(huán)的觀察者，發(fā)通知進行告知。
其中，_per_run_data指針標記為volatile，即告知編譯器要直接從原地址讀取值，而不是從寄存器中讀取（防止多線程更改時不修改寄存器中的值導致的數(shù)據(jù)不一致問題）。__CFRunLoopPushPerRunData函數(shù)的內(nèi)部實現(xiàn)為：
typedef struct _per_run_data {
uint32_t a;
uint32_t b;
uint32_t stopped;
uint32_t ignoreWakeUps;
} _per_run_data;
CF_INLINE volatile _per_run_data *__CFRunLoopPushPerRunData(CFRunLoopRef rl) {
volatile _per_run_data *previous = rl->_perRunData;
rl->_perRunData = (volatile _per_run_data *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(_per_run_data), 0);
rl->_perRunData->a = 0x4346524C;
rl->_perRunData->b = 0x4346524C; // 'CFRL'
rl->_perRunData->stopped = 0x00000000;
rl->_perRunData->ignoreWakeUps = 0x00000000;
return previous;
}
可以看到，runloop的_perRunData成員每次都是創(chuàng)建固定的新值。用來管理runloop的相關設置（stop狀態(tài)，是否允許喚醒等）
- 調(diào)用 __CFRunLoopRun 函數(shù)，此函數(shù)才是真正的運行循環(huán)過程。后面進行單獨說明。
- 運行循環(huán)執(zhí)行結束后，恢復現(xiàn)場。將上一次的運行mode、_perRunData等數(shù)據(jù)進行恢復。且如果存在監(jiān)聽退出狀態(tài)的觀察者，發(fā)通知告知。
這里，我們看一下runloop是如何給觀察者發(fā)送通知的。
2.2 __CFRunLoopDoObservers
static void __CFRunLoopDoObservers() __attribute__((noinline));
static void __CFRunLoopDoObservers(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFRunLoopActivity activity) { /* DOES CALLOUT */
CHECK_FOR_FORK();
// 查看mode中observers的個數(shù)
CFIndex cnt = rlm->_observers ? CFArrayGetCount(rlm->_observers) : 0;
// 不存在，直接返回
if (cnt < 1) return;
/* Fire the observers */
STACK_BUFFER_DECL(CFRunLoopObserverRef, buffer, (cnt <= 1024) ? cnt : 1);
// cnt超過1024后，開辟cnt個內(nèi)存空間，相當于數(shù)組
CFRunLoopObserverRef *collectedObservers = (cnt <= 1024) ? buffer : (CFRunLoopObserverRef *)malloc(cnt * sizeof(CFRunLoopObserverRef));
CFIndex obs_cnt = 0;
for (CFIndex idx = 0; idx < cnt; idx++) {
// 依次取出observer
CFRunLoopObserverRef rlo = (CFRunLoopObserverRef)CFArrayGetValueAtIndex(rlm->_observers, idx);
// 若observer中存在需要的activity
if (0 != (rlo->_activities & activity) && __CFIsValid(rlo) && !__CFRunLoopObserverIsFiring(rlo)) {
// retain后，插入數(shù)組中
collectedObservers[obs_cnt++] = (CFRunLoopObserverRef)CFRetain(rlo);
}
}
// 釋放mode的鎖
__CFRunLoopModeUnlock(rlm);
// 釋放run loop鎖
__CFRunLoopUnlock(rl);
// **** 由此可以看出，為了提高訪問效率，將所有的觀察者添加到額外的數(shù)組中，是為了釋放鎖后，其他對象的高效訪問。 ****
for (CFIndex idx = 0; idx < obs_cnt; idx++) {
// 從數(shù)組中依次取出observer
CFRunLoopObserverRef rlo = collectedObservers[idx];
// 對observer加鎖
__CFRunLoopObserverLock(rlo);
if (__CFIsValid(rlo)) {
// 根據(jù)是否重復確定是否需要置為無效
Boolean doInvalidate = !__CFRunLoopObserverRepeats(rlo);
// 設置對應位的值（標記為正在調(diào)用）
__CFRunLoopObserverSetFiring(rlo);
// 釋放鎖
__CFRunLoopObserverUnlock(rlo);
// 調(diào)用觀察者對應的回調(diào)方法（_callout）
__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(rlo->_callout, rlo, activity, rlo->_context.info);
// 需要置為無效，則釋放此observer
if (doInvalidate) {
CFRunLoopObserverInvalidate(rlo);
}
// 設置對應位的值（標記為沒有調(diào)用）
__CFRunLoopObserverUnsetFiring(rlo);
} else {
// 觀察者對象錯誤，直接釋放鎖
__CFRunLoopObserverUnlock(rlo);
}
// 釋放observer（數(shù)組不再保留observer）
CFRelease(rlo);
}
// 釋放runloop和mode的鎖
__CFRunLoopLock(rl);
__CFRunLoopModeLock(rlm);
// 創(chuàng)建了新數(shù)組，則釋放內(nèi)存
if (collectedObservers != buffer) free(collectedObservers);
}
- 將指定run loop mode中的_observers取出，單獨放到一個指定數(shù)組中進行處理（超出1024個observer后要單獨開辟內(nèi)存）。由于調(diào)用callback函數(shù)為同步操作，由可能會長時間鎖住runloop和mode。故單獨處理，防止影響runloop的執(zhí)行效率。
- 將監(jiān)聽的activity對應的observer插入到數(shù)組容器中。activity即上面說過的CFOptionFlags，也就是runloop運行過程中的各種監(jiān)控時間點。
- 插入到數(shù)組容器時要對observer進行保留操作，使用后要對observer進行釋放操作，內(nèi)存管理要時刻謹記。
- 在observer數(shù)組中依次取出，通過 CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION 函數(shù)對observer的_callout進行函數(shù)調(diào)用。
static void __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(CFRunLoopObserverCallBack func, CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) {
if (func) {
func(observer, activity, info);
}
getpid(); // thwart tail-call optimization
}
主要就是直接進行函數(shù)調(diào)用（getpid神馬進程相關的，就不動了。。。）。
2.3 __CFRunLoopRun
前面說了，__CFRunLoopRun個才是核心所在，真正的“l(fā)oop”在這里執(zhí)行。
由于代碼過長，我們分步驟看。
2.3.1 其他（非do-while循環(huán)）
static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {
// 1. 狀態(tài)判斷
if (__CFRunLoopIsStopped(rl)) {
// 如果runloop已經(jīng)stop（_perRunData中的stop的值）
// 恢復stop為初值，返回已stop狀態(tài)
__CFRunLoopUnsetStopped(rl);
return kCFRunLoopRunStopped;
} else if (rlm->_stopped) {
// 若當前mode已經(jīng)stop
// 恢復stop為初值，返回已stop狀態(tài)
rlm->_stopped = false;
return kCFRunLoopRunStopped;
}
// 2. dispatchPort的獲取
// 派發(fā)端口，如果當前runloop是主線程runloop，則為主隊列port，否則為NULL
mach_port_name_t dispatchPort = MACH_PORT_NULL;
Boolean libdispatchQSafe = pthread_main_np() && ((HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && NULL == previousMode) || (!HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && 0 == _CFGetTSD(__CFTSDKeyIsInGCDMainQ)));
if (libdispatchQSafe && (CFRunLoopGetMain() == rl) && CFSetContainsValue(rl->_commonModes, rlm->_name)) {
dispatchPort = _dispatch_get_main_queue_port_4CF();
}
// 3. 超時定時器的設置
dispatch_source_t timeout_timer = NULL;
struct __timeout_context *timeout_context = (struct __timeout_context *)malloc(sizeof(*timeout_context));
if (seconds <= 0.0) { // instant timeout
// 不設置超時的情況，即運行完就散
seconds = 0.0;
timeout_context->termTSR = 0ULL;
} else if (seconds <= TIMER_INTERVAL_LIMIT) {
// 有超時，但是未達到上限的情況
// 通過global隊列，添加一個超時的timer，到時間喚醒線程，釋放runloop
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, DISPATCH_QUEUE_OVERCOMMIT);
timeout_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_retain(timeout_timer);
timeout_context->ds = timeout_timer;
timeout_context->rl = (CFRunLoopRef)CFRetain(rl);
timeout_context->termTSR = startTSR + __CFTimeIntervalToTSR(seconds);
dispatch_set_context(timeout_timer, timeout_context);
// source gets ownership of context
dispatch_source_set_event_handler_f(timeout_timer, __CFRunLoopTimeout);
dispatch_source_set_cancel_handler_f(timeout_timer, __CFRunLoopTimeoutCancel);
uint64_t ns_at = (uint64_t)((__CFTSRToTimeInterval(startTSR) + seconds) * 1000000000ULL);
dispatch_source_set_timer(timeout_timer, dispatch_time(1, ns_at), DISPATCH_TIME_FOREVER, 1000ULL);
dispatch_resume(timeout_timer);
} else { // infinite timeout
// 超過上限，即無限運行時間的情況
seconds = 9999999999.0;
timeout_context->termTSR = UINT64_MAX;
}
int32_t retVal = 0;
do {
...
} while (0 == retVal);
// retVal只要不為0，則runloop結束循環(huán)，退出
if (timeout_timer) {
// 存在超時定時器，移除
dispatch_source_cancel(timeout_timer);
dispatch_release(timeout_timer);
} else {
free(timeout_context);
}
return retVal;
}
非核心部分主要做了三件事：
- 對runloop和currentMode的運行狀態(tài)進行判斷，防止無畏的運行。
- 根據(jù)情況，查看端口是否為GCD的主隊列端口（用于后面通過主線程自身端口調(diào)用mach_msg函數(shù)，執(zhí)行主隊列的異步任務）。
- 根據(jù)設置的超時時間，使用GCD添加一個定時器，超時時直接釋放runloop。最后結尾時檢查移除此定時器。
2.3.2 do-while運行循環(huán)
int32_t retVal = 0;
do {
// 1. 根據(jù)運行狀態(tài)，進行預處理（發(fā)通知、執(zhí)行block、準備處理GCD事件、休眠）
// 存在kCFRunLoopBeforeTimers的觀察者，發(fā)通知
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
// 存在kCFRunLoopBeforeSources的觀察者，發(fā)通知
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources);
// 調(diào)用block的時機1
__CFRunLoopDoBlocks(rl, rlm);
// 執(zhí)行source0（手動source）
Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
if (sourceHandledThisLoop) {
// 執(zhí)行source0后，調(diào)用block（調(diào)用block的時機2）
__CFRunLoopDoBlocks(rl, rlm);
}
// GCD的主隊列
if (MACH_PORT_NULL != dispatchPort) {
msg = (mach_msg_header_t *)msg_buffer;
// 通過主隊列端口直接發(fā)送消息（內(nèi)部的source1消息，mach_msg執(zhí)行），進行處理
if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0)) {
goto handle_msg;
}
}
// 存在監(jiān)聽kCFRunLoopBeforeWaiting的觀察者，發(fā)通知
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
msg = (mach_msg_header_t *)msg_buffer;
// 嘗試通過mach_msg函數(shù)進入休眠狀態(tài)，接收到消息后（即被喚醒），返回true
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY);
// 如果存在監(jiān)聽kCFRunLoopAfterWaiting的觀察者，發(fā)通知
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
// 2. 處理消息部分（線程已被喚醒 或 直接進入處理）
// ** 處理消息：**
handle_msg:;
if (rlm->_timerPort != MACH_PORT_NULL && livePort == rlm->_timerPort) {
// timer喚醒的
// 以當前時間為時間點，執(zhí)行相應的timer
__CFRunLoopDoTimers(rl, rlm, mach_absolute_time());
} else if (livePort == dispatchPort) {
// GCD主隊列喚醒的（dispatchPort不為NULL，即證明是主隊列喚醒的）
// 執(zhí)行主隊列的任務block
__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
} else {
// 其他線程的source1喚醒的
// 根據(jù)livePort，查詢獲取source1對象
CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);
if (rls) {
mach_msg_header_t *reply = NULL;
// 執(zhí)行source1
sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
}
}
if (msg && msg != (mach_msg_header_t *)msg_buffer) free(msg);
// 執(zhí)行block的時機3
__CFRunLoopDoBlocks(rl, rlm);
// 3. 根據(jù)狀態(tài)設置retVal值，決定運行循環(huán)是否繼續(xù)
if (sourceHandledThisLoop && stopAfterHandle) {
// 單次執(zhí)行完source
retVal = kCFRunLoopRunHandledSource;
} else if (timeout_context->termTSR < mach_absolute_time()) {
// runloop超時
retVal = kCFRunLoopRunTimedOut;
} else if (__CFRunLoopIsStopped(rl)) {
// runloop已停止
retVal = kCFRunLoopRunStopped;
} else if (rlm->_stopped) {
// runloop的對應mode已停止
retVal = kCFRunLoopRunStopped;
} else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
// runloop執(zhí)行完成
retVal = kCFRunLoopRunFinished;
}
} while (0 == retVal);
雖然代碼很多（已經(jīng)大幅度簡化），但實際上只是分為三部分：
- 根據(jù)運行狀態(tài)，進行預處理：
- 在不同運行狀態(tài)，給觀察者發(fā)通知（準備執(zhí)行timer、準備執(zhí)行source）
- 執(zhí)行block
- 執(zhí)行配置到mode中的source0，成功后再次檢測執(zhí)行block。實現(xiàn)函數(shù)為 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION
- 準備處理GCD事件（通過mach_msg函數(shù)，自身主隊列的port執(zhí)行，存在則直接去處理任務）
- 沒有其他事件時，通過mach_msg函數(shù)，讓線程進入睡眠，同時在接收消息后自動喚醒
- 處理消息部分（線程已被喚醒 或 直接進入處理），根據(jù)端口類型，對執(zhí)行的工作進行區(qū)分：
- 執(zhí)行timer：CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION，其入口函數(shù) __CFRunLoopDoTimers 與 __CFRunLoopDoObservers 實現(xiàn)相似：先將符合要求（剛剛到達或者稍微過時一點的）的timer加入到數(shù)組中，防止長時間鎖住runloop，然后依次調(diào)用 __CFRunLoopDoTimer ，也就是calling_out函數(shù)，完成回調(diào)。
- 執(zhí)行GCD主隊列的異步任務：CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE
- source1的主動喚醒任務：mach_msg，進入內(nèi)核態(tài)，直接進行線程通信
- 再次檢測執(zhí)行block
- 根據(jù)狀態(tài)設置retVal值，決定運行循環(huán)是否繼續(xù)。如果狀態(tài)都不滿足，仍為0，則繼續(xù)執(zhí)行循環(huán)，保證線程不退出。
