RunLoop 是 iOS 和 OS X 開發(fā)中非常基礎的一個概念,面試中我們經(jīng)常會被問到

1.RunLoop 的概念

一般來講，一個線程一次只能執(zhí)行一個任務鳞滨，執(zhí)行完成后線程就會退出蟆淀。如果我們需要一個機制，讓線程能隨時處理事件但并不退出,這時候就需要一個do-while循環(huán),這時候我們的主人公RunLoop就粉墨登場了,其內部就是個do-while循環(huán).

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

這種模型通常被稱作 Event Loop褒链。 Event Loop 在很多系統(tǒng)和框架里都有實現(xiàn)疑苔，比如 Node.js 的事件處理，比如 Windows 程序的消息循環(huán)兵迅，再比如 OSX/iOS 里的 RunLoop恍箭。實現(xiàn)這種模型的關鍵點在于：如何管理事件/消息，如何讓線程在沒有處理消息時休眠以避免資源占用鳍贾、在有消息到來時立刻被喚醒交洗。

特別注意:Runloop是程序一直存在并不斷處理事件的原因

所以，RunLoop 實際上就是一個對象纵散，這個對象管理了其需要處理的事件和消息隐圾，并提供了一個入口函數(shù)來執(zhí)行上面 Event Loop 的邏輯暇藏。線程執(zhí)行了這個函數(shù)后，就會一直處于這個函數(shù)內部 "接受消息->等待->處理" 的循環(huán)中把兔，直到這個循環(huán)結束（比如傳入 quit 的消息）瓮顽，函數(shù)返回。

2.RunLoop 與線程的關系

蘋果不允許直接創(chuàng)建 RunLoop缕贡，它只提供了兩個自動獲取的函數(shù)：CFRunLoopGetMain() 和 CFRunLoopGetCurrent()晾咪。 這兩個函數(shù)內部的邏輯大概是下面這樣:

/// 全局的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曹洽，并先為主線程創(chuàng)建一個 RunLoop。
        loopsDic = CFDictionaryCreateMutable();
        CFRunLoopRef mainLoop = _CFRunLoopCreate();
        CFDictionarySetValue(loopsDic, pthread_main_thread_np(), mainLoop);
    }
     
    /// 直接從 Dictionary 里獲取税产。
    CFRunLoopRef loop = CFDictionaryGetValue(loopsDic, thread));
     
    if (!loop) {
        /// 取不到時辟拷，創(chuàng)建一個
        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與線程之間是一一對應的,其關系是共同保存在同一個全局字典里面,當線程創(chuàng)建的時候,RunLoop是不會主動存在的,如果你不主動獲取,那它一直都不會有,RunLoop創(chuàng)建是在第一次獲取的時候,消滅是在線程結束的時候

注意:主線程除外

RunLoop與線程之間關系總結如下

• 1.一個Runloop對應著一條唯一的線程笤喳，一條線程最多有一個Runloop；開啟一個Runloop能讓子線程不死
• 2.Runloop的創(chuàng)建：主線程Runloop已經(jīng)創(chuàng)建好了蒙畴，子線程的runloop需要手動創(chuàng)建并開啟
• 3.Runloop的生命周期：在第一次獲取時創(chuàng)建膳凝，在線程結束時銷毀

3.RunLoop 對外的接口

在 CoreFoundation 里面關于 RunLoop 有5個類:

• CFRunLoopRef
• CFRunLoopModeRef
• CFRunLoopSourceRef
• CFRunLoopTimerRef
• CFRunLoopObserverRef

其中 CFRunLoopModeRef 類并沒有對外暴露恭陡，只是通過 CFRunLoopRef 的接口進行了封裝。他們的關系如下:

關系.png

一個 RunLoop 包含若干個 Mode著淆，每個 Mode 又包含若干個 Source/Timer/Observer牧抽。每次調用 RunLoop 的主函數(shù)時遥赚，只能指定其中一個 Mode阐肤，這個Mode被稱作 CurrentMode。如果需要切換 Mode愧薛，只能退出 Loop，再重新指定一個 Mode 進入瓮栗。這樣做主要是為了分隔開不同組的 Source/Timer/Observer瞄勾，讓其互不影響。
CFRunLoopSourceRef 是事件產(chǎn)生的地方矢空。Source有兩個版本：Source0 和 Source1。

• Source0 只包含了一個回調（函數(shù)指針）缔御，它并不能主動觸發(fā)事件牌捷。使用時喳资，你需要先調用 CFRunLoopSourceSignal(source)仆邓，將這個 Source 標記為待處理，然后手動調用 CFRunLoopWakeUp(runloop) 來喚醒 RunLoop徙硅，讓其處理這個事件搞疗。

• Source1 包含了一個 mach_port 和一個回調（函數(shù)指針），被用于通過內核和其他線程相互發(fā)送消息桩皿。這種 Source 能主動喚醒 RunLoop 的線程幢炸，其原理在下面會講到宛徊。

CFRunLoopTimerRef 是基于時間的觸發(fā)器逻澳，它和 NSTimer 是toll-free bridged 的斜做，可以混用湾揽。其包含一個時間長度和一個回調（函數(shù)指針）库物。當其加入到 RunLoop 時，RunLoop會注冊對應的時間點定硝，當時間點到時蔬啡，RunLoop會被喚醒以執(zhí)行那個回調镀虐。

CFRunLoopObserverRef 是觀察者，每個 Observer 都包含了一個回調（函數(shù)指針）空猜，當 RunLoop 的狀態(tài)發(fā)生變化時辈毯，觀察者就能通過回調接受到這個變化谆沃∫敲ⅲ可以觀測的時間點有以下幾個：

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
};

4.RunLoop 的 Mode

CFRunLoopMode 和 CFRunLoop 的結構大致如下：

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 可以將自己標記為"Common"屬性（通過將其 ModeName 添加到 RunLoop 的 "commonModes" 中）据沈。每當 RunLoop 的內容發(fā)生變化時，RunLoop 都會自動將 _commonModeItems 里的 Source/Observer/Timer 同步到具有 "Common" 標記的所有Mode里锌介。

應用場景舉例：主線程的 RunLoop 里有兩個預置的 Mode：kCFRunLoopDefaultMode 和 UITrackingRunLoopMode掏湾。這兩個 Mode 都已經(jīng)被標記為"Common"屬性肿嘲。DefaultMode 是 App 平時所處的狀態(tài)雳窟，TrackingRunLoopMode 是追蹤 ScrollView 滑動時的狀態(tài)。當你創(chuàng)建一個 Timer 并加到 DefaultMode 時拇涤，Timer 會得到重復回調誉结，但此時滑動一個TableView時鹅士，RunLoop 會將 mode 切換為 TrackingRunLoopMode，這時 Timer 就不會被回調惩坑，并且也不會影響到滑動操作掉盅。

有時你需要一個 Timer，在兩個 Mode 中都能得到回調以舒，一種辦法就是將這個 Timer 分別加入這兩個 Mode趾痘。還有一種方式，就是將 Timer 加入到頂層的 RunLoop 的 "commonModeItems" 中蔓钟。"commonModeItems" 被 RunLoop 自動更新到所有具有"Common"屬性的 Mode 里去。

CFRunLoop對外暴露的管理 Mode 接口只有下面2個:

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(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef modeName);
CFRunLoopRemoveObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef modeName);
CFRunLoopRemoveTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);

你只能通過 mode name 來操作內部的 mode侣集，當你傳入一個新的 mode name 但 RunLoop 內部沒有對應 mode 時，RunLoop會自動幫你創(chuàng)建對應的 CFRunLoopModeRef狭魂。對于一個 RunLoop 來說雌澄，其內部的 mode 只能增加不能刪除镐牺。

蘋果公開提供的Mode有兩個:kCFRunLoopDefaultMode (NSDefaultRunLoopMode)和UITrackingRunLoopMode,你可以用這兩個Mode Name來操作其對應的Mode睬涧。

同時蘋果還提供了一個操作 Common 標記的字符串：kCFRunLoopCommonModes (NSRunLoopCommonModes)旗唁，你可以用這個字符串來操作 Common Items检疫，或標記一個 Mode 為 "Common"屎媳。使用時注意區(qū)分這個字符串和其他 mode name烛谊。

5.RunLoop 的內部邏輯

根據(jù)蘋果在文檔里的說明丹禀，RunLoop 內部的邏輯大致如下:

RunLoop內部邏輯.png

/// 用DefaultMode啟動
void CFRunLoopRun(void) {
    CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
}
  
/// 用指定的Mode啟動，允許設置RunLoop超時時間
int CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean stopAfterHandle) {
    return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}
  
/// RunLoop的實現(xiàn)
int CFRunLoopRunSpecific(runloop, modeName, seconds, stopAfterHandle) {
     
    /// 首先根據(jù)modeName找到對應mode
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(runloop, modeName, false);
    /// 如果mode里沒有source/timer/observer, 直接返回攒读。
    if (__CFRunLoopModeIsEmpty(currentMode)) return;
     
    /// 1. 通知 Observers: RunLoop 即將進入 loop薄扁。
    __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopEntry);
     
    /// 內部函數(shù)邓梅，進入loop
    __CFRunLoopRun(runloop, currentMode, seconds, returnAfterSourceHandled) {
         
        Boolean sourceHandledThisLoop = NO;
        int retVal = 0;
        do {
  
            /// 2. 通知 Observers: RunLoop 即將觸發(fā) Timer 回調日缨。
            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeTimers);
            /// 3. 通知 Observers: RunLoop 即將觸發(fā) Source0 (非port) 回調。
            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeSources);
            /// 執(zhí)行被加入的block
            __CFRunLoopDoBlocks(runloop, currentMode);
             
            /// 4. RunLoop 觸發(fā) Source0 (非port) 回調毅待。
            sourceHandledThisLoop = __CFRunLoopDoSources0(runloop, currentMode, stopAfterHandle);
            /// 執(zhí)行被加入的block
            __CFRunLoopDoBlocks(runloop, currentMode);
  
            /// 5. 如果有 Source1 (基于port) 處于 ready 狀態(tài)尸红，直接處理這個 Source1 然后跳轉去處理消息外里。
            if (__Source0DidDispatchPortLastTime) {
                Boolean hasMsg = __CFRunLoopServiceMachPort(dispatchPort, &msg)
                if (hasMsg) goto handle_msg;
            }
             
            /// 通知 Observers: RunLoop 的線程即將進入休眠(sleep)鳖链。
            if (!sourceHandledThisLoop) {
                __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeWaiting);
            }
             
            /// 7. 調用 mach_msg 等待接受 mach_port 的消息。線程將進入休眠, 直到被下面某一個事件喚醒乞旦。
            /// ? 一個基于 port 的Source 的事件兰粉。
            /// ? 一個 Timer 到時間了
            /// ? RunLoop 自身的超時時間到了
            /// ? 被其他什么調用者手動喚醒
            __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort) {
                mach_msg(msg, MACH_RCV_MSG, port); // thread wait for receive msg
            }
  
            /// 8. 通知 Observers: RunLoop 的線程剛剛被喚醒了愕秫。
            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopAfterWaiting);
             
            /// 收到消息戴甩，處理消息甜孤。
            handle_msg:
  
            /// 9.1 如果一個 Timer 到時間了缴川，觸發(fā)這個Timer的回調把夸。
            if (msg_is_timer) {
                __CFRunLoopDoTimers(runloop, currentMode, mach_absolute_time())
            } 
  
            /// 9.2 如果有dispatch到main_queue的block恋日，執(zhí)行block谚鄙。
            else if (msg_is_dispatch) {
                __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
            } 
  
            /// 9.3 如果一個 Source1 (基于port) 發(fā)出事件了闷营，處理這個事件
            else {
                CFRunLoopSourceRef source1 = __CFRunLoopModeFindSourceForMachPort(runloop, currentMode, livePort);
                sourceHandledThisLoop = __CFRunLoopDoSource1(runloop, currentMode, source1, msg);
                if (sourceHandledThisLoop) {
                    mach_msg(reply, MACH_SEND_MSG, reply);
                }
            }
             
            /// 執(zhí)行加入到Loop的block
            __CFRunLoopDoBlocks(runloop, currentMode);
             
  
            if (sourceHandledThisLoop && stopAfterHandle) {
                /// 進入loop時參數(shù)說處理完事件就返回速蕊。
                retVal = kCFRunLoopRunHandledSource;
            } else if (timeout) {
                /// 超出傳入?yún)?shù)標記的超時時間了
                retVal = kCFRunLoopRunTimedOut;
            } else if (__CFRunLoopIsStopped(runloop)) {
                /// 被外部調用者強制停止了
                retVal = kCFRunLoopRunStopped;
            } else if (__CFRunLoopModeIsEmpty(runloop, currentMode)) {
                /// source/timer/observer一個都沒有了
                retVal = kCFRunLoopRunFinished;
            }
             
            /// 如果沒超時，mode里沒空唉锌，loop也沒被停止袄简，那繼續(xù)loop绿语。
        } while (retVal == 0);
    }
     
    /// 10. 通知 Observers: RunLoop 即將退出吕粹。
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
}

可以看到匹耕，實際上 RunLoop 就是這樣一個函數(shù)泌神，其內部是一個 do-while 循環(huán)欢际。當你調用 CFRunLoopRun() 時损趋，線程就會一直停留在這個循環(huán)里浑槽；直到超時或被手動停止桐玻，該函數(shù)才會返回铣卡。

6.蘋果用 RunLoop 實現(xiàn)的功能

首先我們可以看一下 App 啟動后 RunLoop 的狀態(tài)：

CFRunLoop {
    current mode = kCFRunLoopDefaultMode
    common modes = {
        UITrackingRunLoopMode
        kCFRunLoopDefaultMode
    }
  
    common mode items = {
  
        // source0 (manual)
        CFRunLoopSource {order =-1, {
            callout = _UIApplicationHandleEventQueue}}
        CFRunLoopSource {order =-1, {
            callout = PurpleEventSignalCallback }}
        CFRunLoopSource {order = 0, {
            callout = FBSSerialQueueRunLoopSourceHandler}}
  
        // source1 (mach port)
        CFRunLoopSource {order = 0,  {port = 17923}}
        CFRunLoopSource {order = 0,  {port = 12039}}
        CFRunLoopSource {order = 0,  {port = 16647}}
        CFRunLoopSource {order =-1, {
            callout = PurpleEventCallback}}
        CFRunLoopSource {order = 0, {port = 2407,
            callout = _ZL20notify_port_callbackP12__CFMachPortPvlS1_}}
        CFRunLoopSource {order = 0, {port = 1c03,
            callout = __IOHIDEventSystemClientAvailabilityCallback}}
        CFRunLoopSource {order = 0, {port = 1b03,
            callout = __IOHIDEventSystemClientQueueCallback}}
        CFRunLoopSource {order = 1, {port = 1903,
            callout = __IOMIGMachPortPortCallback}}
  
        // Ovserver
        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,    // BeforeWaiting | Exit
            callout = _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv}
        CFRunLoopObserver {order = 2147483647, activities = 0xa0, // BeforeWaiting | Exit
            callout = _wrapRunLoopWithAutoreleasePoolHandler}
  
        // Timer
        CFRunLoopTimer {firing = No, interval = 3.1536e+09, tolerance = 0,
            next fire date = 453098071 (-4421.76019 @ 96223387169499),
            callout = _ZN2CAL14timer_callbackEP16__CFRunLoopTimerPv (QuartzCore.framework)}
    },
  
    modes ＝ {
        CFRunLoopMode  {
            sources0 =  { /* same as 'common mode items' */ },
            sources1 =  { /* same as 'common mode items' */ },
            observers = { /* same as 'common mode items' */ },
            timers =    { /* same as 'common mode items' */ },
        },
  
        CFRunLoopMode  {
            sources0 =  { /* same as 'common mode items' */ },
            sources1 =  { /* same as 'common mode items' */ },
            observers = { /* same as 'common mode items' */ },
            timers =    { /* same as 'common mode items' */ },
        },
  
        CFRunLoopMode  {
            sources0 = {
                CFRunLoopSource {order = 0, {
                    callout = FBSSerialQueueRunLoopSourceHandler}}
            },
            sources1 = (null),
            observers = {
                CFRunLoopObserver >{activities = 0xa0, order = 2000000,
                    callout = _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv}
            )},
            timers = (null),
        },
  
        CFRunLoopMode  {
            sources0 = {
                CFRunLoopSource {order = -1, {
                    callout = PurpleEventSignalCallback}}
            },
            sources1 = {
                CFRunLoopSource {order = -1, {
                    callout = PurpleEventCallback}}
            },
            observers = (null),
            timers = (null),
        },
         
        CFRunLoopMode  {
            sources0 = (null),
            sources1 = (null),
            observers = (null),
            timers = (null),
        }
    }
}

可以看到蝉仇，系統(tǒng)默認注冊了5個Mode:

1. kCFRunLoopDefaultMode: App的默認 Mode轿衔，通常主線程是在這個 Mode 下運行的害驹。
2. UITrackingRunLoopMode: 界面跟蹤 Mode裙秋，用于 ScrollView 追蹤觸摸滑動，保證界面滑動時不受其他 Mode 影響刻坊。
3. UIInitializationRunLoopMode: 在剛啟動 App 時第進入的第一個 Mode谭胚，啟動完成后就不再使用灾而。
   4: GSEventReceiveRunLoopMode: 接受系統(tǒng)事件的內部 Mode旁趟，通常用不到。
   5: kCFRunLoopCommonModes: 這是一個占位的 Mode瞧掺，沒有實際作用辟狈。

你可以在這里看到更多的蘋果內部的 Mode桩砰，但那些 Mode 在開發(fā)中就很難遇到了亚隅。
當 RunLoop 進行回調時煮纵，一般都是通過一個很長的函數(shù)調用出去 (call out), 當你在你的代碼中下斷點調試時匆光，通常能在調用棧上看到這些函數(shù)终息。下面是這幾個函數(shù)的整理版本周崭，如果你在調用棧中看到這些長函數(shù)名续镇，在這里查找一下就能定位到具體的調用地點了：

{
    /// 1. 通知Observers，即將進入RunLoop
    /// 此處有Observer會創(chuàng)建AutoreleasePool: _objc_autoreleasePoolPush();
    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopEntry);
    do {
  
        /// 2. 通知 Observers: 即將觸發(fā) Timer 回調酱虎。
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeTimers);
        /// 3. 通知 Observers: 即將觸發(fā) Source (非基于port的,Source0) 回調读串。
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeSources);
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);
  
        /// 4. 觸發(fā) Source0 (非基于port的) 回調爹土。
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__(source0);
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);
  
        /// 6. 通知Observers，即將進入休眠
        /// 此處有Observer釋放并新建AutoreleasePool: _objc_autoreleasePoolPop(); _objc_autoreleasePoolPush();
        __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喚醒的熄浓，執(zhí)行所有調用 dispatch_async 等方法放入main queue 的 block
        __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(dispatched_block);
  
        /// 9. 如果如果Runloop是被 Source1 (基于port的) 的事件喚醒了俯在，處理這個事件
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__(source1);
  
  
    } while (...);
  
    /// 10. 通知Observers跷乐，即將退出RunLoop
    /// 此處有Observer釋放AutoreleasePool: _objc_autoreleasePoolPop();
    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopExit);
}

AutoreleasePool
App啟動后愕提，蘋果在主線程 RunLoop 里注冊了兩個 Observer，其回調都是 _wrapRunLoopWithAutoreleasePoolHandler()往史。
第一個 Observer 監(jiān)視的事件是 Entry(即將進入Loop)椎例，其回調內會調用 _objc_autoreleasePoolPush() 創(chuàng)建自動釋放池。其 order 是-2147483647肆捕，優(yōu)先級最高眼虱，保證創(chuàng)建釋放池發(fā)生在其他所有回調之前捏悬。

第二個 Observer 監(jiān)視了兩個事件： BeforeWaiting(準備進入休眠) 時調用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 釋放舊的池并創(chuàng)建新池过牙；Exit(即將退出Loop) 時調用 _objc_autoreleasePoolPop() 來釋放自動釋放池寇钉。這個 Observer 的 order 是 2147483647扫倡，優(yōu)先級最低油够，保證其釋放池子發(fā)生在其他所有回調之后石咬。

在主線程執(zhí)行的代碼鬼悠，通常是寫在諸如事件回調、Timer回調內的维贺。這些回調會被 RunLoop 創(chuàng)建好的 AutoreleasePool 環(huán)繞著虐秋，所以不會出現(xiàn)內存泄漏，開發(fā)者也不必顯示創(chuàng)建 Pool 了客给。

事件響應
蘋果注冊了一個 Source1 (基于 mach port 的) 用來接收系統(tǒng)事件靶剑，其回調函數(shù)為 __IOHIDEventSystemClientQueueCallback()。
當一個硬件事件(觸摸/鎖屏/搖晃等)發(fā)生后坑匠，首先由 IOKit.framework 生成一個 IOHIDEvent 事件并由 SpringBoard 接收笛辟。這個過程的詳細情況可以參考這里捷凄。SpringBoard 只接收按鍵(鎖屏/靜音等)跺涤，觸摸桶错，加速，接近傳感器等幾種 Event粪狼，隨后用 mach port 轉發(fā)給需要的App進程再榄。隨后蘋果注冊的那個 Source1 就會觸發(fā)回調嗅蔬，并調用 _UIApplicationHandleEventQueue() 進行應用內部的分發(fā)澜术。
_UIApplicationHandleEventQueue() 會把 IOHIDEvent 處理并包裝成 UIEvent 進行處理或分發(fā)吴趴，其中包括識別 UIGesture/處理屏幕旋轉/發(fā)送給 UIWindow 等锣枝。通常事件比如 UIButton 點擊撇叁、touchesBegin/Move/End/Cancel 事件都是在這個回調中完成的陨闹。

手勢識別
當上面的 _UIApplicationHandleEventQueue() 識別了一個手勢時，其首先會調用 Cancel 將當前的 touchesBegin/Move/End 系列回調打斷胶坠。隨后系統(tǒng)將對應的 UIGestureRecognizer 標記為待處理。

蘋果注冊了一個 Observer 監(jiān)測 BeforeWaiting (Loop即將進入休眠) 事件闻牡，這個Observer的回調函數(shù)是 _UIGestureRecognizerUpdateObserver()罩润，其內部會獲取所有剛被標記為待處理的 GestureRecognizer，并執(zhí)行GestureRecognizer的回調拳球。

當有 UIGestureRecognizer 的變化(創(chuàng)建/銷毀/狀態(tài)改變)時祝峻，這個回調都會進行相應處理莱找。

界面更新
當在操作 UI 時奥溺，比如改變了 Frame、更新了 UIView/CALayer 的層次時桦卒，或者手動調用了 UIView/CALayer 的 setNeedsLayout/setNeedsDisplay方法后方灾，這個 UIView/CALayer 就被標記為待處理裕偿，并被提交到一個全局的容器去拢蛋。

蘋果注冊了一個 Observer 監(jiān)聽 BeforeWaiting(即將進入休眠) 和 Exit (即將退出Loop) 事件谆棱，回調去執(zhí)行一個很長的函數(shù)：

_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv()。這個函數(shù)里會遍歷所有待處理的 UIView/CAlayer 以執(zhí)行實際的繪制和調整个从，并更新 UI 界面嗦锐。

這個函數(shù)內部的調用棧大概是這樣的：

_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 的。一個 NSTimer 注冊到 RunLoop 后嘱根，RunLoop 會為其重復的時間點注冊好事件。例如 10:00, 10:10, 10:20 這幾個時間點凑保。RunLoop為了節(jié)省資源愉适，并不會在非常準確的時間點回調這個Timer。Timer 有個屬性叫做 Tolerance (寬容度)惠爽，標示了當時間點到后租副，容許有多少最大誤差用僧。
如果某個時間點被錯過了，例如執(zhí)行了一個很長的任務院仿，則那個時間點的回調也會跳過去，不會延后執(zhí)行排惨。就比如等公交若贮，如果 10:10 時我忙著玩手機錯過了那個點的公交，那我只能等 10:20 這一趟了匾效。
CADisplayLink 是一個和屏幕刷新率一致的定時器（但實際實現(xiàn)原理更復雜面哼，和 NSTimer 并不一樣，其內部實際是操作了一個 Source）闯袒。如果在兩次屏幕刷新之間執(zhí)行了一個長任務其徙，那其中就會有一幀被跳過去（和 NSTimer 相似）唾那，造成界面卡頓的感覺闹获。在快速滑動TableView時，即使一幀的卡頓也會讓用戶有所察覺茎用。Facebook 開源的 AsyncDisplayLink 就是為了解決界面卡頓的問題，其內部也用到了 RunLoop古涧，這個稍后我會再單獨寫一頁博客來分析。

PerformSelecter
當調用 NSObject 的 performSelecter:afterDelay: 后柒昏，實際上其內部會創(chuàng)建一個 Timer 并添加到當前線程的 RunLoop 中职祷。所以如果當前線程沒有 RunLoop，則這個方法會失效泥耀。
當調用 performSelector:onThread: 時痰催，實際上其會創(chuàng)建一個 Timer 加到對應的線程去弦疮，同樣的，如果對應線程沒有 RunLoop 該方法也會失效压语。

RunLoop基本應用總結

1）開啟NSTimer，控制定時器在特定模式下執(zhí)行
2）可以讓某些事件（行為厕怜、任務）在特定模式下執(zhí)行，如ImageView顯示：控制方法在特定的模式下可用
3）PerformSelector：控制線程執(zhí)行不同的任務
4）常駐線程：讓一個子線程不進入消亡狀態(tài)递雀，等待其他線程發(fā)來消息，處理其他事件
5）可以添加Observer監(jiān)聽RunLoop的狀態(tài)杨凑，比如監(jiān)聽點擊事件的處理（在所有點擊事件之前做一些事情
6）自動釋放池（可通過Observer監(jiān)聽RunLoop的狀態(tài)）
第一次創(chuàng)建：進入runloop的時候
最后一次釋放：runloop退出的時候
其它創(chuàng)建和釋放：當runloop即將休眠的時候會把之前的自動釋放池釋放，然后重新創(chuàng)建一個新的釋放池

7.什么時候使用RunLoop

僅當在為你的程序創(chuàng)建輔助線程的時候，你才需要顯式運行一個run loop曼追。Run loop是程序主線程基礎設施的關鍵部分礼殊。所以碟狞，Cocoa和Carbon程序提供了代碼運行主程序的循環(huán)并自動啟動run loop。IOS程序中UIApplication的run方法（或Mac OS X中的NSApplication）作為程序啟動步驟的一部分脆淹，它在程序正常啟動的時候就會啟動程序的主循環(huán)。類似的烘嘱，RunApplicationEventLoop函數(shù)為Carbon程序啟動主循環(huán)。如果你使用xcode提供的模板創(chuàng)建你的程序蝗蛙，那你永遠不需要自己去顯式的調用這些例程。

對于輔助線程遗契，你需要判斷一個run loop是否是必須的。如果是必須的，那么你要自己配置并啟動它从绘。你不需要在任何情況下都去啟動一個線程的run loop。比如批什，你使用線程來處理一個預先定義的長時間運行的任務時乳规，你應該避免啟動run loop暮的。Run loop在你要和線程有更多的交互時才需要，比如以下情況：

• 使用端口或自定義輸入源來和其他線程通信
• 使用線程的定時器
• Cocoa中使用任何performSelector…的方法
• 使線程周期性工作

總結:RunLoop大概就介紹到這里,還有其它補充的歡迎大家前來探討,大家共同努力