iOS学习之深刻理解RunLoop

RunLoop的定义与概念

RunLoop的主要做用

main函数中的RunLoop

RunLoop与线程的关系

RunLoop的消息种类

RunLoop的对外接口

RunLoop的mode

RunLoop的内部逻辑

RunLoop在iOS中内部的应用

RunLoop在iOS开发中的实践

总结

参考文献

RunLoop的定义与概念

• 顾名思义 RunLoop， 就是一个在Run的loop，就是一个一直在跑的圈。其本质就是无休止的while循环。通常的程序都是执行完任务后便结束。但因为手机应用的特殊性，在其不执行任务时，也不能将其杀死，而是暂时休眠状态，直到有外部或内部因素将其唤醒，继续run。直到用户手动将该程序完全关闭。
• 这种模型一般被称做 Event Loop。 Event Loop 在不少系统和框架里都有实现，好比 Node.js 的事件处理，好比 Windows 程序的消息循环，再好比 OSX/iOS 里的 RunLoop。实现这种模型的关键点在于：如何管理事件/消息，如何让线程在没有处理消息时休眠以免资源占用、在有消息到来时马上被唤醒。
• RunLoop 实际上就是一个对象，这个对象管理了其须要处理的事件和消息，并提供了一个入口函数来执行上面 Event Loop 的逻辑。线程执行了这个函数后，就会一直处于这个函数内部 “接受消息->等待->处理” 的循环中，直到这个循环结束（好比传入 quit 的消息），函数返回。
• 程序例程以下：

// 无Runloop，程序执行完后，直接返回
int main(int argc,char * argv[]){
 	 	NSLog(@"execute main function");---->程序开始
  		return 0; ------------------------->程序结束
}
// 有Runloop
int main(int argc,char * argv[]){
		BOOL running = YES; -------->程序开始
		do {------------------------------
   	// 执行各类任务，处理各类事件------持续运行
		}while(running);---------------------
	    return 0;
}

复制代码

• OSX/iOS 系统中，提供了两个这样的对象：NSRunLoop 和 CFRunLoopRef。
  • CFRunLoopRef 是在 CoreFoundation 框架内的，它提供了纯 C 函数的 API，全部这些 API 都是线程安全的。
  • NSRunLoop 是基于 CFRunLoopRef 的封装，提供了面向对象的 API，可是这些 API 不是线程安全的。

RunLoop的主要做用

• 使程序一直运行并接收用户的输入
• 决定程序在什么时候处理哪些事件
• 调用解耦（主调方产生不少事件，不用等到被调方处理完事件以后，才能执行其余操做）
• 节省CPU时间（当程序启动后，什么都没有执行的话，就不用让CPU来消耗资源来执行，直接进入睡眠状态）

main函数中的RunLoop

• 因为手机应用的特殊性，因此在iOS程序中，main 函数内部也启动了一个RunLoop
• 程序以下

int main(int argc, char * argv[]) {
  @autoreleasepool {
      return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
  }
}
复制代码

• 其中 UIApplicationMain 函数内部帮咱们开启了主线程的 RunLoop ， UIApplicationMain 内部拥有一个无线循环的代码。这个 UIApplicationMain 函数帮咱们启动的 RunLoop 属于程序的主线程全部，因此咱们不须要再为主线程开启 RunLoop。因为咱们的程序在主线程上拥有一个 RunLoop ，因此咱们将程序打开后，执行完它所须要的任务后，不必定非要退出程序，而是能够选择将其后台挂起。一切都是由于 主线程上RunLoop 的关系，咱们的程序才能够长时间持续运行。

RunLoop与线程的关系

• RunLoop 与线程能够说是一一对应的关系。可是不必定必定是一对一，有多是0对1。由于只有在主线程中，咱们的iOS程序帮助咱们开启了 RunLoop。而在咱们本身定义或系统帮咱们开启的子线程中，若是咱们不显式的“建立” RunLoop ,咱们的子线程就没有Runloop。这里所谓的“建立”，并非直接建立 RunLoop ，而是经过调用获取 RunLoop 的方法来完成 RunLoop 的建立，由于在 RunLoop 的内部，其实是经过懒加载方法建立的。这也是咱们若是不调用 获取 方法，就不会得到 RunLoop 的缘由。
• RunLoop 的建立是发生在第一次获取时，RunLoop 的销毁是发生在线程结束时。你只能在一个线程的内部获取其 RunLoop（主线程除外）。
• 获取 Runloop 的方法以下：

  • 在 Core Foundation 中

    • CFRunLoopGetMain() // 获取主线程的Runloop
    • CFRunLoopGetCurrent() // 获取当前线程的Runloop

  • 在 Cocoa 中

    • [NSRunLoop currentRunLoop]

  • CFRunLoopRef 和 NSRunLoop 能够转化, NSRunLoop 使用 getCFRunLoop方法就能够获得 CFRunLoopRef 对象

• 示例代码以下：

/// 全局的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 其实是由字典来进行保存的，这也更加印证了 RunLoop 与线程之间一一对应的关系。

RunLoop的消息种类

• 这是apple官方文档的一张图, 表示了Runloop的消息种类。

• 这张图我也没有特别看懂，主要是讲的Runloop的两种输入源。官方文档的解释是

  • InputSources : 用来投递异步消息,一般消息来自另外的线程或者程序.在接受到消息并调用指定的方法时,线程对应的 NSRunLoop 对象会经过执行 runUntilDate:方法来退出.
  • Timer Source: 用来投递 timer 事件(Schedule 或者 Repeat)中的同步消息.在消息处理时,并不会退出 RunLoop. RunLoop 除了处理以上两种 Input Soruce,它也会在运行过程当中生成不一样的 notifications,标识 runloop 所处的状态,所以能够给 RunLoop 注册观察者 Observer,以便监控 RunLoop 的运行过程,并在 RunLoop 进入某些状态时候进行相应的操做, Apple 只提供了 Core Foundation 的 API来给 RunLoop 注册观察者Observer.

RunLoop的对外接口

• 在 CoreFoundation 里面关于 RunLoop 有5个类:
  • CFRunLoopRef
  • CFRunLoopModeRef
  • CFRunLoopSourceRef
  • CFRunLoopTimerRef
  • CFRunLoopObserverRef
• 其中 CFRunLoopModeRef 类并无对外暴露，只是经过 CFRunLoopRef 的接口进行了封装。他们的关系以下:

• 由图片能够看出，一个 Runloop 中，含有数个 mode ，而其中每一个 mode 又包含数个 source， observer， timer。每次调用 RunLoop 的主函数时，只能指定其中一个 Mode，这个Mode被称做 CurrentMode。若是须要切换 Mode，只能退出 Loop，再从新指定一个 Mode 进入。这样作主要是为了分隔开不一样组的 Source/Timer/Observer，让其互不影响。
• 在这里须要注意的是，在辅助线程启动 runloop 以前, 你必须至少在其中添加一个 input source 或者 timer（详见第三章 Runloop的消息种类）. 若是一个 runloop 中没有一个事件源sources, runloop 会在你启动它之后当即退出.
• 在添加了 source 之后,你能够给 runloop 添加 observers 来监测 runloop 的不一样的执行的状态.为了加入 observer, 你应该建立一个 CFRunLoopObserverRef,使用 CFRunLoopAddObserver 函数添加 observer 到你的 runloop.
• 下面来具体介绍 Runloop 对外提供的这几种接口
  • CFRunLoopSourceRef 是事件产生的地方。Source有两个版本：Source0 和 Source1。
    • Source0 只包含了一个回调（函数指针），它并不能主动触发事件。使用时，你须要先调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理，而后手动调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件。
    • Source1 包含了一个 mach_port（很重要的概念） 和一个回调（函数指针），被用于经过内核和其余线程相互发送消息。这种 Source 能主动唤醒 RunLoop 的线程，具体的请看下面的代码。
  • CFRunLoopTimerRef 是基于时间的触发器，它和 NSTimer 是toll-free bridged 的，能够混用。其包含一个时间长度和一个回调（函数指针）。当其加入到 RunLoop 时，RunLoop会注册对应的时间点，当时间点到时，RunLoop会被唤醒以执行那个回调。
  • CFRunLoopObserverRef 是观察者，每一个 Observer 都包含了一个回调（函数指针），当 RunLoop 的状态发生变化时，观察者就能经过回调接受到这个变化。能够观测的时间点有如下几个：

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry         = (1UL << 0), // 即将进入Loop
    kCFRunLoopBeforeTimers  = (1UL << 1), // 即将处理 Timer
    kCFRunLoopBeforeSources = (1UL << 2), // 即将处理 Source
    kCFRunLoopBeforeWaiting = (1UL << 5), // 即将进入休眠 32
    kCFRunLoopAfterWaiting  = (1UL << 6), // 刚从休眠中唤醒 64
    kCFRunLoopExit          = (1UL << 7), // 即将退出Loop 128
};
复制代码

• 上面的 Source/Timer/Observer 被统称为 mode item，一个 item 能够被同时加入多个 mode。但一个 item 被重复加入同一个 mode 时是不会有效果的。若是一个 mode 中一个 item 都没有，则 RunLoop 会直接退出，不进入循环。

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<Source/Observer/Timer>
    CFRunLoopModeRef _currentMode;    // Current Runloop Mode
    CFMutableSetRef _modes;           // Set
    ...
};

复制代码

• 系统默认注册了5个Mode:

  1. kCFRunLoopDefaultMode: App的默认 Mode，一般主线程是在这个 Mode 下运行的。
  2. UITrackingRunLoopMode: 界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其余 Mode 影响。
  3. UIInitializationRunLoopMode: 在刚启动 App 时第进入的第一个 Mode，启动完成后就再也不使用。
  4. GSEventReceiveRunLoopMode: 接受系统事件的内部 Mode，一般用不到。
  5. kCFRunLoopCommonModes: 这是一个占位的 Mode，没有实际做用。

• 咱们平时主要应用的 mode 有 kCFRunLoopDefaultMode 和 UITrackingRunLoopMode 两种， 其中 kCFRunLoopDefaultMode(在cocoa中也叫NSDefaultRunLoopMode)是咱们开启一个 RunLoop 时默认的 mode 方式。 而 UITrackingRunLoopMode 主要是追踪 ScrollView 滑动时的状态。

• 这里有个概念叫 “CommonModes”：一个 Mode 能够将本身标记为”Common”属性（经过将其 ModeName 添加到 RunLoop 的 “commonModes” 中）。每当 RunLoop 的内容发生变化时，RunLoop 都会自动将 _commonModeItems 里的 Source/Observer/Timer 同步到具备 “Common” 标记的全部Mode里。须要注意的是： “CommonModes”并非一个真正的 mode ， 它其实是一个 数组 里面放入了 kCFRunLoopDefaultMode 和 UITrackingRunLoopMode

• 应用场景举例：主线程的 RunLoop 里有两个预置的 Mode：kCFRunLoopDefaultMode 和 UITrackingRunLoopMode。这两个 Mode 都已经被标记为”Common”属性。DefaultMode 是 App 平时所处的状态，UITrackingRunLoopMode 是追踪 ScrollView 滑动时的状态。当你建立一个 Timer 并加到 DefaultMode 时，Timer 会获得重复回调，但此时滑动一个TableView时，RunLoop 会将 mode 切换为 UITrackingRunLoopMode，这时 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会自动帮你建立对应的 CFRunLoopModeRef。对于一个 RunLoop 来讲，其内部的 mode 只能增长不能删除。

RunLoop的内部逻辑

• 先放一张我认为很是好的图,其中仍是有些错误之处，根据官方文档，第7步：休眠，等待唤醒的source种类应该是source1，而不是source0。

• 内部代码实现以下 若是嫌太长，直接看注释便可。

/// 用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的实现
int CFRunLoopRunSpecific(runloop, modeName, seconds, stopAfterHandle) {
    
    /// 首先根据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
            __CFRunLoopDoBlocks(runloop, currentMode);
            
            /// 4. RunLoop 触发 Source0 (非port) 回调。
            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);
}

复制代码

• 能够注意到，在这段代码在第5步，跳转到第9步执行source1的事件时，使用了 goto 语句，可见，专一底层的大神就是跟咱们普通人不同啊哈哈哈。
• 实际上 RunLoop 就是这样一个函数，其内部是一个 do-while 循环。当你调用 CFRunLoopRun() 时，线程就会一直停留在这个循环里；直到超时或被手动中止，该函数才会返回。
• RunLoop 的核心就是一个 mach_msg() (见上面代码的第7步)，RunLoop 调用这个函数去接收消息，若是没有别人发送 port 消息过来，内核会将线程置于等待状态。例如你在模拟器里跑起一个 iOS 的 App，而后在 App 静止时点击暂停，你会看到主线程调用栈是停留在 mach_msg_trap() 这个地方。
• 为了实现消息的发送和接收，mach_msg() 函数其实是调用了一个 Mach 陷阱 (trap)，即函数mach_msg_trap()，陷阱这个概念在 Mach 中等同于系统调用。当你在用户态调用 mach_msg_trap() 时会触发陷阱机制，切换到内核态；内核态中内核实现的 mach_msg() 函数会完成实际的工做，以下图：

RunLoop在iOS中内部的应用

• 当 RunLoop 进行回调时，通常都是经过一个很长的函数调用出去 (call out), 当你在你的代码中下断点调试时，一般能在调用栈上看到这些函数。下面是这几个函数的整理版本，若是你在调用栈中看到这些长函数名，在这里查找一下就能定位到具体的调用地点了：

{
    /// 1. 通知Observers，即将进入RunLoop
    /// 此处有Observer会建立AutoreleasePool: _objc_autoreleasePoolPush();
    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopEntry);
    do {
 
        /// 2. 通知 Observers: 即将触发 Timer 回调。
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeTimers);
        /// 3. 通知 Observers: 即将触发 Source (非基于port的,Source0) 回调。
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeSources);
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);
 
        /// 4. 触发 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唤醒的，执行全部调用 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 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush() 建立自动释放池。其 order 是-2147483647，优先级最高，保证建立释放池发生在其余全部回调以前。
• 第二个 Observer 监视了两个事件： BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并建立新池；Exit(即将退出Loop) 时调用_objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 的 order 是 2147483647，优先级最低，保证其释放池子发生在其余全部回调以后。
• 在主线程执行的代码，一般是写在诸如事件回调、Timer回调内的。这些回调会被 RunLoop 建立好的 AutoreleasePool 环绕着，因此不会出现内存泄漏，开发者也没必要显示建立 Pool 了。

事件响应

• 苹果注册了一个 Source1 (基于 mach port 的) 用来接收系统事件，其回调函数为 __IOHIDEventSystemClientQueueCallback()。
• 当一个硬件事件(触摸/锁屏/摇晃等)发生后，首先由 IOKit.framework 生成一个 IOHIDEvent 事件并由 SpringBoard 接收。SpringBoard 只接收按键(锁屏/静音等)，触摸，加速，接近传感器等几种 Event，随后用 mach port 转发给须要的App进程。随后苹果注册的那个 Source1 就会触发回调，并调用 _UIApplicationHandleEventQueue()进行应用内部的分发。
• _UIApplicationHandleEventQueue() 会把 IOHIDEvent 处理并包装成 UIEvent 进行处理或分发，其中包括识别 UIGesture/处理屏幕旋转/发送给 UIWindow 等。一般事件好比 UIButton 点击、touchesBegin/Move/End/Cancel 事件都是在这个回调中完成的。
• 须要注意的是 基于UI的事件响应，都是属于 source1 的，虽然打印信息栈时，显示的是 source0 ，但实际上，首先是由Source1 接收 IOHIDEvent ，以后在回调 __IOHIDEventSystemClientQueueCallback() 内触发的 Source0，Source0 再触发的 _UIApplicationHandleEventQueue()。因此 UIButton 事件看到是在 Source0 内的。

手势识别

• 当上面的_UIApplicationHandleEventQueue() 识别了一个手势时，其首先会调用 Cancel 将当前的 touchesBegin/Move/End 系列回调打断。随后系统将对应的 UIGestureRecognizer 标记为待处理。 苹果注册了一个 Observer 监测 BeforeWaiting (Loop即将进入休眠) 事件，这个Observer的回调函数是 _UIGestureRecognizerUpdateObserver()，其内部会获取全部刚被标记为待处理的 GestureRecognizer，并执行GestureRecognizer的回调。 当有 UIGestureRecognizer 的变化(建立/销毁/状态改变)时，这个回调都会进行相应处理。

界面更新

• 当在操做 UI 时，好比改变了 Frame、更新了 UIView/CALayer 的层次时，或者手动调用了 UIView/CALayer 的 setNeedsLayout/setNeedsDisplay方法后，这个 UIView/CALayer 就被标记为待处理，并被提交到一个全局的容器去。
• 苹果注册了一个 Observer 监听 BeforeWaiting(即将进入休眠) 和 Exit (即将退出Loop) 事件，回调去执行一个很长的函数： _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv()。这个函数里会遍历全部待处理的 UIView/CAlayer 以执行实际的绘制和调整，并更新 UI 界面。

定时器

• NSTimer 其实就是 CFRunLoopTimerRef，他们之间是 toll-free bridged 的。一个 NSTimer 注册到 RunLoop 后，RunLoop 会为其重复的时间点注册好事件。例如 10:00, 10:10, 10:20 这几个时间点。RunLoop为了节省资源，并不会在很是准确的时间点回调这个Timer。Timer 有个属性叫作 Tolerance (宽容度)，标示了当时间点到后，允许有多少最大偏差。
• 若是某个时间点被错过了，例如执行了一个很长的任务，则那个时间点的回调也会跳过去，不会延后执行。就好比等公交，若是 10:10 时我忙着玩手机错过了那个点的公交，那我只能等 10:20 这一趟了。
• CADisplayLink 是一个和屏幕刷新率一致的定时器（但实际实现原理更复杂，和 NSTimer 并不同，其内部实际是操做了一个 Source）。若是在两次屏幕刷新之间执行了一个长任务，那其中就会有一帧被跳过去（和 NSTimer 类似），形成界面卡顿的感受。在快速滑动TableView时，即便一帧的卡顿也会让用户有所察觉。

PerformSelecter

• 当调用 NSObject 的 performSelecter:afterDelay: 后，实际上其内部会建立一个 Timer 并添加到当前线程的 RunLoop 中。因此若是当前线程没有 RunLoop，则这个方法会失效。
• 当调用 performSelector:onThread: 时，实际上其会建立一个 Timer 加到对应的线程去，一样的，若是对应线程没有 RunLoop 该方法也会失效。

关于GCD

• GCD 自己与 RunLoop 是属于平级的关系。 他们谁也不包含谁，可是他们之间存在着协做的关系。
• 当调用 dispatch_async(dispatch_get_main_queue(), block) 时，libDispatch 会向主线程的 RunLoop 发送消息，RunLoop会被唤醒，并从消息中取得这个 block，并在回调 __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__() 里执行这个 block。但这个逻辑仅限于 dispatch 到主线程，dispatch 到其余线程仍然是由 libDispatch 处理的。

Runloop在iOS开发中的实践

AFNetworking

• 这里有一个已经被将烂了的例子，即 AFNetworking 内部的 AFURLConnectionOperation 类，使用 RunLoop 来保持“长链接”， 目的是为了让 RunLoop 不至于退出，并无用于实际的发送消息。 由于RunLoop 启动前内部必需要有至少一个 Timer/Observer/Source，因此 AFNetworking 在 [runLoop run] 以前先建立了一个新的 NSMachPort 添加进去了。
• 代码以下：

+ (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;
}
复制代码

• 这里有一个坑，是否 AFNetworking 这样作了，咱们就能够跟着这样作来保持回调的 “长链接” 呢？ 答案是否认的。

AsyncDisplayKit

• UI 线程中一旦出现繁重的任务就会致使界面卡顿，这类任务一般分为3类：排版，绘制，UI对象操做。
• 排版一般包括计算视图大小、计算文本高度、从新计算子式图的排版等操做。 绘制通常有文本绘制 (例如 CoreText)、图片绘制 (例如预先解压)、元素绘制 (Quartz)等操做。 UI对象操做一般包括 UIView/CALayer 等 UI 对象的建立、设置属性和销毁。
• 其中前两类操做能够经过各类方法扔到后台线程执行，而最后一类操做只能在主线程完成，而且有时后面的操做须要依赖前面操做的结果 （例如TextView建立时可能须要提早计算出文本的大小）。ASDK 所作的，就是尽可能将能放入后台的任务放入后台，不能的则尽可能推迟 (例如视图的建立、属性的调整)。
• 为此，ASDK 建立了一个名为 ASDisplayNode 的对象，并在内部封装了 UIView/CALayer，它具备和 UIView/CALayer 类似的属性，例如 frame、backgroundColor等。全部这些属性均可以在后台线程更改，开发者能够只经过 Node 来操做其内部的 UIView/CALayer，这样就能够将排版和绘制放入了后台线程。可是不管怎么操做，这些属性总须要在某个时刻同步到主线程的 UIView/CALayer 去。
• ASDK 仿照 QuartzCore/UIKit 框架的模式，实现了一套相似的界面更新的机制：即在主线程的 RunLoop 中添加一个 Observer，监听了 kCFRunLoopBeforeWaiting 和 kCFRunLoopExit 事件，在收到回调时，遍历全部以前放入队列的待处理的任务，而后一一执行。 具体的代码能够看这里：_ASAsyncTransactionGroup。

ImageView推迟显示

• 利用PerformSelector设置当前线程的RunLoop的运行模式

  [self.imageView performSelector:@selector(setImage:) withObject:[UIImage imageNamed:@"tupian"] afterDelay:4.0 inModes:NSDefaultRunLoopMode];
  
  复制代码

后台常驻线程（很经常使用）

• 解释上述 AFNetworking 长时间链接问题 。

• 方法1即 AFNetworking 中使用的方法，它使得 thread 在打开后，使用结束方法CFRunLoopStop(CFRunLoopGetCurrent())并无正常结束，该结束方法对这个建立 Thread 的方式无效。因此致使了内存暴增，图以下

• 方法2 如图，因为它是一个非线程阻塞的方法，因此有时在线程还已经退出后，才开始暂停这个线程，天然会使得程序崩溃。

• 方法3 才是我推荐的方法 ，它能够正确的建立一个后台常驻线程。

  • 执行结果以下

• 下面解释一下原理吧

  • CFRunLoopStop() 方法只会结束当前的 runMode:beforeDate: 调用，而不会结束后续的调用。
  • 而咱们所知道，系统所谓的 run() 方法，实际上就是在内部不断地调用runMode:beforeDate:方法，而所谓的runUntilDate:方法，也是有限的调用runMode:beforeDate:方法。只是它们所传的参数都是DefaultMode罢了。
  • 而正常结束一个 RunLoop 的方法只有两种
    • 设置超时时间
    • 使用CFRunLoopStop()方法手动将 RunLoop 结束。
  • 通常咱们使用设置超时时间便可，可是在网络传输中，咱们想达到的目标就是在精准的时间点结束 RunLoop， 因此咱们须要使用CFRunLoopStop()方法手动将 RunLoop 结束。
  • 而CFRunLoopStop()方法的定义中说了。

  The difference is that you can use this technique on run loops you started unconditionally.

  • 官方文档在 run 方法的定义中则说

  If you want the run loop to terminate, you shouldn't use this method

  • 这也就表示了，若是还想从 RunLoop 中退出，就不能使用 run 方法来 run 一个 loop。
  • 而且重要的是， CFRunLoopStop() 方法只会结束当前的 runMode:beforeDate: 调用，而不会结束后续的调用。这也就是为何 Runloop 的文档中说CFRunLoopStop() 能够 exit(退出) 一个 RunLoop，而在 run 等方法的文档中又说这样会致使 RunLoop 没法 terminate(终结)。

总结

• 之前对 RunLoop 能够说是一窍不通， 只知道有这么个名词，在实际的编程中，也历来没有使用过，一直都想深刻研究一下，索性这两天比较用时间，就花了两天时间找了大量的资料来理解，总结 RunLoop， 在这个过程当中不免会有不少疏漏，也请有缘看到这篇文章的大家不吝赐教。谢谢O(∩_∩)O~

参考文献

• YYKit做者的Runloop理解，讲的最清楚，对我影响最大
• 孙源线下Runloop分享的笔记整理
• Runloop更加深刻的理解
• 苹果官方Runloop文档的中文翻译
• 苹果官方文档
• 关于Runloop线程保活与内存泄漏的理解
• 很是浅显易懂的Runloop理解
• 孙源的线下Runloop分享(这个本身找视频吧)