iOS runloop 相关梳理

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

主线程的 RunLoop 里有两个预置的 Mode：kCFRunLoopDefaultMode 和 UITrackingRunLoopMode。这两个 Mode 都已经被标记为”Common”属性
CFRunLoop对外暴露的管理 Mode 接口只有下面2个:

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

Mode 暴露的管理 mode item 的接口有下面几个：

你只能通过 mode name 来操作内部的 mode，当你传入一个新的 mode name 但 RunLoop 内部没有对应 mode 时，RunLoop会自动帮你创建对应的 CFRunLoopModeRef。对于一个 RunLoop 来说，其内部的 mode 只能增加不能删除。
苹果公开提供的 Mode 有两个：kCFRunLoopDefaultMode (NSDefaultRunLoopMode) 和 UITrackingRunLoopMode，你可以用这两个 Mode Name 来操作其对应的 Mode。
同时苹果还提供了一个操作 Common 标记的字符串：kCFRunLoopCommonModes (NSRunLoopCommonModes)，你可以用这个字符串来操作 Common Items，或标记一个 Mode 为 “Common”。使用时注意区分这个字符串和其他 mode name。

### Runloop 事件
其实在主线程的任何一个断点，都可以看到调用堆栈信息里面都有CFRunLoop这家伙的影子，一般都是由以下6个回调上来的：

1.
///触发 Source0 (非基于port的) 回调，处理如UIEvent，CFSocket这类事件。需要手动触发。
///触摸事件其实是Source1接收系统事件后在回调__IOHIDEventSystemClientQueueCallback()内触发的Source0
__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__
2.
///如果如果Runloop是被 Source1 (基于port的) 的事件唤醒了，处理这个事件
///处理系统内核的mach_msg事件
__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__
3.  
///被dispatch唤醒，执行放入main_queue的block
__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
4.
///被timer唤醒
__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
5.
///通知observer当前runloop的状态
__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__
6.
///非延迟的block事件调用，CFRunLoopPerformBlock，立即执行一个block
__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__


### RunLoop 的内部逻辑

![7aab9f00eb57aec05e3b18a3d2086374](/assets/img/runloop/3CE7FCCD-C423-4FAA-BE9E-5220BF1AA752.png)
![9fcfa628373f496d0747b334c96f42ff](/assets/img/runloop/835216A3-48E1-48F5-ABF3-C0C1139CB9DD.png)


1. 通知 observer，进入runloop
2. 通知 observer，即将处理 timer 事件
3. 通知 observer，即将处理 source 事件
4. 处理block，runloop 是可以添加 block 的(CFRunLoopPerformBlock(<#CFRunLoopRef rl#>, <#CFTypeRef mode#>, <#^(void)block#>))
5. 处理 source 0
6. 处理 source1事件，如果存在就处理，跳转到第8
7. 通知 observer 即将休眠
8. 通知 observer 结束休眠（timer 事件，source1 事件等）
9. 然后根据前面的执行结果，决定是否再次循环

/// 首先根据modeName找到对应mode
CFRunLoopModeRef currentMode = __CFRunLoopFindMode(runloop, modeName, false);
/// 如果mode里没有source/timer/observer, 直接返回。
if (__CFRunLoopModeIsEmpty(currentMode)) return;

/// 1. 通知 Observers: RunLoop 即将进入 loop。
__CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopEntry);

/// 内部函数，进入loop
__CFRunLoopRun(runloop, currentMode, seconds, returnAfterSourceHandled) {
    
    Boolean sourceHandledThisLoop = NO;
    int retVal = 0;
    do {
 
        /// 2. 通知 Observers: RunLoop 即将触发 Timer 回调。
        __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeTimers);
        /// 3. 通知 Observers: RunLoop 即将触发 Source0 (非port) 回调。
        __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeSources);
        /// 执行被加入的block, 处理非延迟的主线程调用
        /// 一个循环中会调用两次，确保非延迟的NSObject PerformSelector调用和非延迟的dispatch_after调用在当前runloop执行。还有回调block 不知道哪个是对的
        __CFRunLoopDoBlocks(runloop, currentMode);
        
        /// 4. RunLoop 触发 Source0 (非port) 回调。 // 处理UIevent等
        sourceHandledThisLoop = __CFRunLoopDoSources0(runloop, currentMode, stopAfterHandle);
        /// 执行被加入的block
        __CFRunLoopDoBlocks(runloop, currentMode);
 
        /// 5. 如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 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 到时间了，触发这个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 (基于port) 发出事件了，处理这个事件
        else {
            CFRunLoopSourceRef source1 = __CFRunLoopModeFindSourceForMachPort(runloop, currentMode, livePort);
            sourceHandledThisLoop = __CFRunLoopDoSource1(runloop, currentMode, source1, msg);
            if (sourceHandledThisLoop) {
                mach_msg(reply, MACH_SEND_MSG, reply);
            }
        }
        
        /// 执行加入到Loop的block // 再次确保是否有同步的方法需要调用
        __CFRunLoopDoBlocks(runloop, currentMode);
        
 
        if (sourceHandledThisLoop && stopAfterHandle) {
            /// 进入loop时参数说处理完事件就返回。
            retVal = kCFRunLoopRunHandledSource;
        } else if (timeout) {
            /// 超出传入参数标记的超时时间了
            retVal = kCFRunLoopRunTimedOut;
        } else if (__CFRunLoopIsStopped(runloop)) {
            /// 被外部调用者强制停止了
            retVal = kCFRunLoopRunStopped;
        } else if (__CFRunLoopModeIsEmpty(runloop, currentMode)) {
            /// source/timer/observer一个都没有了
            retVal = kCFRunLoopRunFinished;
        }
        
        /// 如果没超时，mode里没空，loop也没被停止，那继续loop。
    } while (retVal == 0);
}

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

分析一下这两者的区别

 __CFRunLoopDoObservers(kCFRunLoopBeforeTimers);

 __CFRunLoopDoObservers(kCFRunLoopBeforeSources);

 __CFRunLoopDoBlocks();  //一个循环中会调用两次，确保非延迟的NSObject PerformSelector调用和非延迟的dispatch_after调用在当前runloop执行。还有回调block

 __CFRunLoopDoSource0(); //例如UIKit处理的UIEvent事件

 CheckIfExistMessagesInMainDispatchQueue(); //GCD dispatch main queue

 __CFRunLoopDoObservers(kCFRunLoopBeforeWaiting); //即将进入休眠，会重绘一次界面

 var wakeUpPort = SleepAndWaitForWakingUpPorts();

 // mach_msg_trap，陷入内核等待匹配的内核mach_msg事件

 // Zzz...

 // Received mach_msg, wake up

 __CFRunLoopDoObservers(kCFRunLoopAfterWaiting);

 // Handle msgs

 if (wakeUpPort == timerPort) {

      __CFRunLoopDoTimers();

 } else if (wakeUpPort == mainDispatchQueuePort) {

      //GCD当调用dispatch_async(dispatch_get_main_queue(),block)时，libDispatch会向主线程的runloop发送mach_msg消息唤醒runloop，并在这里执行。这里仅限于执行dispatch到主线程的任务，dispatch到其他线程的仍然是libDispatch来处理。

      __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__()

 } else {

      __CFRunLoopDoSource1();  //CADisplayLink是source1的mach_msg触发？

 }

 __CFRunLoopDoBlocks();

_isReloadDone = NO;

[tableView reload]; //会自动设置tableView layoutIfNeeded为YES，意味着将会在runloop结束时重绘table

dispatch_async(dispatch_get_main_queue(),^{

    _isReloadDone = YES;

});

当你调用 CFRunLoopRun() 时，线程就会一直停留在这个循环里；直到超时或被手动停止，该函数才会返回。
RunLoop 的核心就是一个 mach_msg() (见上面代码的第7步)，RunLoop 调用这个函数去接收消息，如果没有别人发送 port 消息过来，内核会将线程置于等待状态。例如你在模拟器里跑起一个 iOS 的 App，然后在 App 静止时点击暂停，你会看到主线程调用栈是停留在 mach_msg_trap() 这个地方。

### 卡顿检查

从上可以看出RunLoop处理事件的时间主要出在两个阶段：
* kCFRunLoopBeforeSources和kCFRunLoopBeforeWaiting之间
* kCFRunLoopAfterWaiting之后
所以监测下面两个状态
if (self->_activity == kCFRunLoopBeforeSources || self->_activity == kCFRunLoopAfterWaiting) {

###  事件响应

系统注册了一个 Source1 用来接收系统事件，其回调函数为 __IOHIDEventSystemClientQueueCallback()。当一个硬件事件(触摸/锁屏/摇晃等)发生后，首先由 IOKit.framework 生成一个 IOHIDEvent 事件并由 SpringBoard 接收。
(SpringBoard 只接收按键(锁屏/静音等)、触摸、加速，传感器等几种事件)
随后用 mach port 转发给需要的App进程。随后系统注册的那个 Source1 就会触发回调，并调用_UIApplicationHandleEventQueue()进行应用内部的分发。 _UIApplicationHandleEventQueue()会把 IOHIDEvent 事件处理并包装成 UIEvent 进行处理或分发，其中包括识别 UIGesture/处理屏幕旋转/发送给 UIWindow 等。通常事件比如 UIButton 点击、touchesBegin/Move/End/Cancel 事件都是在这个回调中完成的。

###  界面更新

iOS 的显示系统是由 VSync 信号驱动的，VSync 信号由硬件时钟生成，每秒钟发出 60 次（这个值取决设备硬件，比如 iPhone 真机上通常是 59.97）。iOS 图形服务接收到 VSync 信号后，会通过 IPC 通知到 App 内。App 的 Runloop 在启动后会注册对应的 CFRunLoopSource 通过 mach_port 接收传过来的时钟信号通知，随后 Source 的回调会驱动整个 App 的动画与显示。

Core Animation 在 RunLoop 中注册了一个 Observer，监听了 BeforeWaiting 和 Exit 事件。当一个触摸事件到来时，RunLoop 被唤醒，App 中的代码会执行一些操作，比如创建和调整视图层级、设置 UIView 的 frame、修改 CALayer 的透明度、为视图添加一个动画；这些操作最终都会被 CALayer 标记，并通过 CATransaction 提交到一个中间状态去。当上面所有操作结束后，RunLoop 即将进入休眠（或者退出）时，关注该事件的 Observer 都会得到通知。这时 Core Animation 注册的那个 Observer 就会在回调中，把所有的中间状态合并提交到 GPU 去显示；如果此处有动画，通过 DisplayLink 稳定的刷新机制会不断的唤醒runloop，使得不断的有机会触发observer回调，从而根据时间来不断更新这个动画的属性值并绘制出来。
为了不阻塞主线程，Core Animation 的核心是 OpenGL ES 的一个抽象物，所以大部分的渲染是直接提交给GPU来处理

在操作 UI 时，比如改变了 Frame、更新了 UIView/CALayer 的层次时，或者手动调用了 UIView/CALayer 的 setNeedsLayout/setNeedsDisplay方法后，这个 UIView/CALayer 就被标记为待处理，并被提交到一个全局的容器去。

苹果注册了一个 Observer 监听 BeforeWaiting(即将进入休眠) 和 Exit (即将退出Loop) 事件，回调去执行一个很长的函数：_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv()。这个函数里会遍历所有待处理的 UIView/CAlayer 以执行实际的绘制和调整，并更新 UI 界面。
这个函数内部的调用栈大概是这样的：

### RunLoop与GCD关系

1. RunLoop 的超时时间就是使用 GCD 中的 
2. dispatch_source_t来实现的内部注册了GCD的系统事件，调用了dispatch_async(dispatch_get_main_queue(), <#^(void)block#>)时，libDispatch会向主线程RunLoop发送消息唤醒RunLoop，RunLoop从消息中获取block，并且在__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__回调里执行这个block。dispatch_after同理。如图：
![5895d1a1bdc995ef5de15b2b82e68f3b](/assets/img/runloop/4F34EEC6-30CB-4703-AA00-0F243EEA6018.png)

### 线程保活的三种方式
1. [runLoop addPort:[NSMachPort port] forMode:NSRunLoopCommonModes];
2. 子线程创建timer，repeats=yes，其实就是让runloop一直处于有接受timer source的状态条件锁或信号量，子线程里写一个循环，/** 让子线程任务进入闲等状态 
3. 

 void kill()从双向链表中移除当前AutoreleasePoolPage节点后的所有节点，包括节点本身。注意kill()不包含释放对象的操作，只是简单移除节点。
 void kill() 
{
    AutoreleasePoolPage *page = this;
    while (page->child) page = page->child;

    AutoreleasePoolPage *deathptr;
    do {
        deathptr = page;
        page = page->parent;
        if (page) {
            page->child = nil;
        }
        delete deathptr;
    } while (deathptr != this);
}

self.displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(handleDisplayLink:)];    
[self.displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
停止方法
[self.displayLink invalidate];  
self.displayLink = nil;