（最全）RunLoop 原理+使用场景+面试总结

RunLoop 是 iOS 和 OSX 开发中非常基础的一个概念。

网上已经有很多源码分析和具体Demo的研究。

写这篇文章的目的是把目前网上能够找到的文章进行一个整体梳理。希望能帮到大家。

这篇文章将从 CFRunLoop 的源码入手，介绍 RunLoop 的概念以及底层实现原理。

具体目录如下：

一、RunLoop 的基本概念

二、RunLoop 相关类以及构成要素

三、RunLoop的运行逻辑

四、苹果官方 RunLoop 实际应用

五、第三方库 RunLoop 的运用

六、开发中常见 RunLoop 使用 （如果对原理不感兴趣，可以直接跳到末尾看实际使用，这样有的放矢，阅读效率更高）

七、RunLoop 可能的面试套路

一、基本概念

1、runloop是什么? ———— O

用一个字来形容runloop的话，runloop就是————圈。

或者说是英文字母——O。

这样的形象比喻，想要说明的是runloop的特性——runloop是一个事件循环对象。

一般来讲，一个线程一次只能执行一个任务，执行完成后线程就会退出。如果我们需要一个机制，让线程能随时处理事件但并不退出，通常的代码逻辑是这样的：

do {

//接受消息->等待->处理

}while(message != quit)

线程执行了这个函数后，就会一直处于这个函数内部 "接受消息->等待->处理" 的循环中，直到这个循环结束（比如传入 quit 的消息），函数返回。

2、没有runloop会怎样？

上面这样的运行机制通常被称作 Event Loop。 Event Loop 在很多系统和框架里都有实现，

比如 Node.js 的事件处理，比如 Windows 程序的消息循环，再比如 OSX/iOS 里的 RunLoop。

实现这种模型的关键点在于：如何管理事件/消息，如何让线程在没有处理消息时休眠以避免资源占用、在有消息到来时立刻被唤醒。

如果iOS APP 没有runloop 机制会怎么样呢？

如果没有runloop的机制的话，我们的app，从一启动到退出程序时间会很短。

更加形象的说，app一启动就死了。

所以，runloop 的存在，就是保住app的生命，让app 可以随时待命，处理用户的操作以及其他事件。

runloop的重要性就在于：我们控制了runloop ,就是控制了app 的生死。

二、runloop 的相关类以及构成要素

1、runloop 相关类

在 iOS 中，RunLoop 就是个对象。

众所周知，OC 语言是对于 C 的封装。所以呢，会有两个框架，一个是 CoreFoundation，一个是面向对象的 Foundation。

全文在解释原理的时候，是直接使用底层 CoreFoundation 的源码解释。

在 CoreFoundation 框架为 CFRunLoopRef 对象，它提供了纯 C 函数的 API，并且这些 API 是线程安全的；

而在 Foundation 框架中用 NSRunLoop 对象来表示，它是基于 CFRunLoopRef 的封装，提供的是面向对象的 API，但这些 API 不是线程安全的。

CFRunLoopRef 的代码是开源的，我们可以在 这里 或 这里 找到 CFRunLoop.c 来查看 RunLoop 的源码。

2、构成元素

在 CoreFoundation 中关于 RunLoop 有 5 个类：

CFRunLoopRef

CFRunLoopModeRef

CFRunLoopSourceRef

CFRunLoopTimerRef

CFRunLoopObserverRef

一个Runloop对应一条线程，一个runloop里面可以有多个CFRunLoopModeRef(模式）。

同一个时刻，RunLoop只能是在一个mode上面的运行。如果需要切换mode,只能是退出currentMode ,切换到指定的 mode 。

每一个mode又可以包含多个 source/timer/observer。不同 mode 里面的子元素，互不影响。

5个类的对应关系大概是：

相关类.png

下面具体介绍这个CFRunLoop里面的4个类。
CFRunLoopModeRef

官方文档介绍如下：

A run loop mode is a collection of input sources and timers to be monitored and a collection of run loop observers to be notified.
You must be sure to add one or more input sources, timers, or run-loop observers to any modes you create for them to be useful.
You use modes to filter out events from unwanted sources during a particular pass through your run loop.

即一个 run loop mode 是若干个 source、timer 和 observer 的集合。它能帮我们过滤掉一些不想要的事件。

即一个 RunLoop 在某个 mode 下运行时，不会接收和处理其他 mode 的事件 。

要保持一个 mode 活着，就必须往里面添加至少一个 source、timer 或 observer 。

这一点很容易理解，你想啊，如果一个 mode 里面什么东西都没有，那么他根本就没有活干，那 mode 活着还有什么意思。

苹果公开的 mode 有两个：kCFRunLoopDefaultMode (NSDefaultRunLoopMode) 和 UITrackingRunLoopMode。

前者是默认的模式，程序运行的大多时候都处于该 mode 下，后者是滑动 tableView 或 scrollerView 时为了界面流畅而用的 mode。

还有个 UIInitializationRunLoopMode 是程序启动时进入的 mode，一般用不上。

以上，两个公开常用的 mode, 在执行的时候，相互独立，互不干扰。

这样让不同的mode各司其职，对于程序运行的解耦很有好处。

但是如果偏偏想要让两个互相不干扰的mode,都做同一件事情可以实现么？

可以实现的。苹果爸爸，想到了这一点。

CFRunLoop里面有一个伪mode叫做 kCFRunLoopCommonModes，它不是一个真正的 mode，而是若干个 mode 的集合。

你可以把这个 kCFRunLoopCommonModes 理解成：折磨你改需求的产品经理。

kCFRunLoopDefaultMode 就是写android的程序员，UITrackingRunLoopMode是写iOS的程序员。

产品经理一个需求，两个程序员必须都要实现这个功能。

我们往 CommonModes 里面加入 任意的 source/timer/observer 。

就可以想象成是产品经理有新的需求。Android 和 iOS 程序员都要把需求实现。

只要加入到了 CommonModes 里面，就相当于添加到了它里面所有的 mode 中（当然，根据各自的情况，可能不仅仅只要默认的两个 mode ）。

我们可以通过 NSLog(@"%@", [NSRunLoop currentRunLoop]) 从打印结果看到 CommonMode 包含了上面的 DefaultMode 和 TrackingRunLoopMode。

common modes = {type = mutable set, count = 2, entries =>
0 : {contents = "UITrackingRunLoopMode"}

2 : {contents = "kCFRunLoopDefaultMode"}
}

CFRunLoopSourceRef

source 是事件产生的地方（输入源），虽然官方文档在概念上把 source 分为三类：Port-Based Sources，Custom Input Sources，Cocoa Perform Selector Sources。

但在源码中 source 只有两个版本：source0 和 source1，它们的区别在于它们是怎么被标记 (signal) 的。

source0 是app内部的消息机制，使用时需要调用 CFRunLoopSourceSignal()来把这个 source 标记为待处理，然后掉用 CFRunLoopWakeUp() 来唤醒 RunLoop，让其处理这个事件。

source1 是基于 mach_ports 的，用于通过内核和其他线程互相发送消息。

iOS / OSX 都是基于 Mach 内核，Mach 的对象间的通信是通过消息在两个端口(port)之间传递来完成。

很多时候我们的 app 都是处于什么事都不干的状态，在空闲前指定用于唤醒的 mach port 端口，然后在空闲时被 mach_msg() 函数阻塞着并监听唤醒端口， mach_msg() 又会调用 mach_msg_trap() 函数从用户态切换到内核态，这样系统内核就将这个线程挂起，一直停留在 mac_msg_trap 状态。直到另一个线程向内核发送这个端口的 msg 后， trap 状态被唤醒， RunLoop 继续开始干活。

其实，总结下来，事件产生的地方就是source(输入源), 运用发消息的机制，让事件可以唤醒休眠的runloop执行。

具体细节，可以参见：RunLoop 详解

CFRunLoopTimerRef

看到 timer 是不是很熟悉？

这里的 timer 看起来名字是用C语言的样式，其实是完全等价于我们在OC里面的计时器NSTimer。

所以，在平时编程的过程中，我们最开始意识到有 runloop 这回事，就是了使用 NSTimer 的时候。这一点在后面的具体场景应用会详细提到的。

另外，这个 CFRunLoopTimerRef，还可以由方法 performSelector:afterDelay:来触发。（因为，本质上 afterDelay, 底层就是启动了 timer ,不然怎么检测具体时间，然后调用回调方法呢。）

CFRunLoopObserverRef

看到名字就应该知道这就是一个观察者。它的主要用途就是监听 RunLoop 的状态变化。

它可以监听RunLoop的7种状态：

/* Run Loop Observer Activities */

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {

// 即将进入 loop
kCFRunLoopEntry = (1UL << 0),

// 即将处理 timer
kCFRunLoopBeforeTimers = (1UL << 1),

// 即将处理 source
kCFRunLoopBeforeSources = (1UL << 2),

// 即将 sleep
kCFRunLoopBeforeWaiting = (1UL << 5),

// 刚被唤醒，退出 sleep
kCFRunLoopAfterWaiting = (1UL << 6),

// 即将退出
kCFRunLoopExit = (1UL << 7),

// 全部的活动
kCFRunLoopAllActivities = 0x0FFFFFFFU

};

三、RunLoop的运行逻辑

1、获取RunLoop

苹果官方对于 RunLoop 的创建进行了封装，也就是说我们找不到像alloc 或者 new 这样的方法去手动创建RunLoop。

要获取主线程或当前线程对应的 RunLoop，只能通过 CFRunLoopGetMain 或 CFRunLoopGetCurrent 函数。

获取过程大概是：

    >  // 全局的 dictionary, key 是 pthread_t， value 是 CFRunLoopRef
    static CFMutableDictionaryRef __CFRunLoops = NULL;
    
    CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    // 第一次进入时，创建全局 dictionary
    if (!__CFRunLoops) {
        // 创建可变字典
        CFMutableDictionaryRef dict = CFDictionaryCreateMutable();
        // 先创建主线程的 RunLoop
        CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
        // 主线程的 RunLoop 存进字典中
        CFDictionarySetValue(dict, pthread_main_thread_np(), mainLoop);
    }
        
    // 用 传进来的线程 作 key，获取对应的 RunLoop
    CFRunLoopRef loop = CFDictionaryGetValue(__CFRunLoops, t);
        
    // 如果获取不到，则新建一个，并存入字典
    if (!loop) {
        CFRunLoopRef newLoop = __CFRunLoopCreate(t);
        CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
    }
    return loop;
    }
    
    // 获取主线程的 RunLoop
    CFRunLoopRef CFRunLoopGetMain(void) {
    if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np());
    return __main;
}

// 获取当前线程的 RunLoop
CFRunLoopRef CFRunLoopGetCurrent(void) {
    return _CFRunLoopGet0(pthread_self());
}

从上面的代码可以看出, runloop 和 pthread_t （也就是线程）是一一对应的。

这样一一对应的关系是保存在一个全局的 dictionary 中的。

内部产生 runloop 的机制，与我们 iOS 开发中常用的懒加载很相似。

只有到了第一次要使用的时候，才回去创建。当线程销毁的时候，也销毁相应的 runloop。

2、runloop 运行逻辑

runloop 整个的运行逻辑都是在于三个重要的对象如何运作：source （输入源）、timer （定时器）、observer (观察者)。

上面的关于 runloop 的相关类里面有过介绍，observer 时刻监听，整个 runloop 的7种 状态的变化。

在上面 7 种状态里面，对应着不同的处理。

网上的参考逻辑图如下：

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的实现
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);
}

可以看到，这里 runloop 的整个运行逻辑就是一个 do-while 循环。

就是我们开篇说的一个——圈。

一旦调用了 CFRunLoopRun ,线程就会一直停留在这个循环里面；只有当超时或者被手动停止，函数才会返回，也就是退出了当前的 runloop 。

总结成一句话就是：runloop 的运行逻辑就是 do-while 循环下运用观察者模式（或者说是消息发送），根据7种状态的变化，处理事件输入源和定时器。

四、苹果官方 RunLoop 实际应用

RunLoop 作为 iOS app 底层最重要的运行机制，基本运用在一个APP构成的方方方面。
下面请大家跟我一起来看看，说起来那么晕头转向的 RunLoop, 到底可以解释那些 iOS 的常见机制。

先来看一道面试题吧（这是我刚开始工作是一个 JAVA面试官问的）：

请问 iOS 的NSAutoreleasePool（自动释放池）在什么时候释放？

我当时的很纳闷，难道不是到了@autorelease 的 ‘}’（反大括号）就释放了。

相对正确的答案应该是：退出 runloop 之前释放。

这样就引出了 RunLoop 的第一个应用—— 自动释放池。

1、自动释放池

这里的举例分析的是 APP 启动的时候，与主线程同时生成的自动释放池。

在打印 [NSRunLoop currentRunLoop] 的结果中我们可以看到与自动释放池相关的：

{activities = 0x1, callout =
_wrapRunLoopWithAutoreleasePoolHandler}

{activities = 0xa0, callout =
_wrapRunLoopWithAutoreleasePoolHandler}

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 了。

与主线程的 RunLoop 运行逻辑类似，在程序中自定义的自动释放池，也是在即将退出 RunLoop 的时候，释放创建的自动释放池。

2、NSTimer (定时器)

NSTimer 其实就是 CFRunLoopTimerRef，他们之间是 toll-free bridged 的。

上面有讲到 RunLoop 本身就是一个圈。更进一步说：不断地围着圈跑。

这个特性，很像城市里环城巴士。

一个 NSTimer 注册到 RunLoop 后，RunLoop 会为其重复的时间点注册好事件。

例如 10:00, 10:10, 10:20 这几个时间点。RunLoop为了节省资源，并不会在非常准确的时间点回调这个Timer。

Timer 有个属性叫做 Tolerance (宽容度)，标示了当时间点到后，容许有多少最大误差。

如果某个时间点被错过了，例如执行了一个很长的任务，则那个时间点的回调也会跳过去，不会延后执行。就比如等公交，如果 10:10 时我忙着玩手机错过了那个点的公交，那我只能等 10:20 这一趟了。

3、PerformSelecter...

当调用 NSObject 的 performSelecter:afterDelay: 后，实际上其内部会创建一个 Timer 并添加到当前线程的 RunLoop 中。所以如果当前线程没有 RunLoop，则这个方法会失效。

当调用 performSelector:onThread: 时，实际上其会创建一个 Timer 加到对应的线程去，同样的，如果对应线程没有 RunLoop 该方法也会失效。

4、事件响应

苹果注册了一个 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 事件都是在这个回调中完成的。

5、手势识别

当上面的 _UIApplicationHandleEventQueue() 识别了一个手势时，其首先会调用 Cancel 将当前的 touchesBegin/Move/End 系列回调打断。

随后系统将对应的 UIGestureRecognizer 标记为待处理。

苹果注册了一个 Observer 监测 BeforeWaiting (Loop即将进入休眠) 事件，这个Observer的回调函数是 _UIGestureRecognizerUpdateObserver()，其内部会获取所有刚被标记为待处理的 GestureRecognizer，并执行GestureRecognizer的回调。

当有 UIGestureRecognizer 的变化(创建/销毁/状态改变)时，这个回调都会进行相应处理。

6、UI更新

在当前 RunLoop 的打印结果我们还可以看到

{activities = 0xa0,callout = 
_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv}

即准备进入睡眠和即将退出 loop 两个时间点，会调用函数更新 UI 界面.

当在操作 UI 时，某个需要变化的 UIView/CALayer 就被标记为待处理，然后被提交到一个全局的容器去，再在上面的回调执行时才会被取出来进行绘制和调整。

所以如果在一次运行循环中想用如下方法设置一个 view 的两条移动路径是行不通的。因为它会把视图的属性变化汇总起来，直接让 myView 从起点移动到终点了：

CGRect frame = self.myView.frame;
// 先向下移动
frame.origin.y += 200;
[UIView animateWithDuration:1 animations:^{
self.myView.frame = frame;
[self.myView setNeedsDisplay];
}];

// 再向右移动
frame.origin.x += 200;
[UIView animateWithDuration:1 animations:^{
    self.myView.frame = frame;
    [self.myView setNeedsDisplay];
}];

在仔细分析一下，上面代码的逻辑。

第一个动画是想要做到用1秒的时间，Y 值增加200。第二个动画想要实现的是用1秒的时间，X 值增加200.

想要实现的先下后右。

但是这样是无法实现的。因为，UI的绘制是拿到所有之后，在统一绘制的。

7、GCD

RunLoop 底层会用到 GCD 的东西，GCD 的某些 API 也用到了 RunLoop。如当调用了 dispatch_async(dispatch_get_main_queue(), block)时，主队列会把该 block 放到对应的线程（恰好是主线程）中，主线程的 RunLoop 会被唤醒，从消息中取得这个 block，回调 CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE() 来执行这个 block：

GCD.png

五、第三方库 RunLoop 的运用

1、AFNetWorking 里面的常驻线程

(友情提醒：NSURLConnection 在 AFNetWorking 3.0 及以后已经弃用)

子线程默认是完成任务后结束。当要经常使用子线程，每次开启子线程比较耗性能。此时可以开启子线程的 RunLoop，保持 RunLoop 运行，则使子线程保持不死。AFNetworking 基于 NSURLConnection 时正是这样做的，希望在后台线程能保持活着，从而能接收到 delegate 的回调。

这一点充分体现了：我们控制了runloop ,就是控制了app 的生死。

具体做法是：

            /* 返回一个线程 */
+ (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;
    }
/* 在新开的线程中执行的第一个方法 */
+ (void)networkRequestThreadEntryPoint:(id)__unused object {
    @autoreleasepool {
        [[NSThread currentThread] setName:@"AFNetworking"];
        // 获取当前线程对应的 RunLoop
        NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
        // 为 RunLoop 添加 source，模式为 DefaultMode
        [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
        // 开始运行 RunLoop
        [runLoop run];
    }
}

因为 RunLoop 启动前必须设置一个 mode，而 mode 要存在则至少需要一个 source / timer。所以上面的做法是为 RunLoop 的 DefaultMode 添加一个 NSMachPort 对象，虽然消息是可以通过 NSMachPort 对象发送到 loop 内，但这里添加的 port 只是为了 RunLoop 一直不退出，而没有发送什么消息。当然我们也可以添加一个超长启动时间的 timer 来既保持 RunLoop 不退出也不占用资源。

2、AsyncDisplayKit

AsyncDisplayKit 是 Facebook 推出的用于保持界面流畅性的框架，其原理大致如下：

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 事件，在收到回调时，遍历所有之前放入队列的待处理的任务，然后一一执行。

六、开发中常见 RunLoop 使用

上面系统介绍了苹果官方对于 RunLoop 的使用和常见的第三方类库的使用。

但是，我们实际应用最多的可能会是下面这些具体场景。

1、UIImageView 延迟加载图片

假设我们有一个UITableView，UITableView上面有很多UITableViewCell，UITableViewCell上面有一个UIImageView（你可以想象QQ的聊天页面）。这时候一般我们的需求都是那个UIImageView的图片需要你从网络上下载，并且异步，下载成功之后更新到UIImageView上。

实际上这个时候我们就会碰到问题，因为我们的UITab
leView是可以任意拖动的，所以如果不更改NSURLConnection的运行模式，那么只要 UItableView 出现滑动，NSURLConnection 所在的DefaultMode 就会退出，切换到 UITrackingRunLoopMode 。

给 UIImageView 设置图片可能耗时不少，如果此时要滑动 tableView 等则可能影响到界面的流畅。

解决是：使用 performSelector:withObject:afterDelay:inModes: 方法，将设置图片的方法放到 DefaultMode 中执行。

为了流畅性，把图片加载延迟。

2、UITableView 与 NSTimer 冲突

由于 UItabelView 在滑动的时候，会从当前的 RunLoop 默认的模式 kCFRunLoopDefaultMode (NSDefaultRunLoopMode) 退出，进入到 UITrackingRunLoopMode。

这个时候，处于 NSDefaultRunLoopMode 里面的 NSTimer 由于切换了模式造成计时器无法继续运行。

可以两个解决方法：（目的就是：即使 mode 切换，计时器依然工作）

此处参考：iOS下RunLoop的实际应用场景探究

七、RunLoop 可能的面试套路

RunLoop面试小结

什么是RunLoop?

从字面上看:运行循环、跑圈

其实它内部就是do-while循环,在这个循环内部不断的处理各种任务(比如Source、Timer、Observer)

一个线程对应一个RunLoop,主线程的RunLoop默认已经启动,子线程的RunLoop需要手动启动(调用run方法)
RunLoop只能选择一个Mode启动,如果当前Mode中没有任何Soure、Timer、Observer,那么就直接退出RunLoop

在开发中如何使用RunLoop?什么应用场景?
    开启一个常驻线程(让一个子线程不进入消亡状态,等待其他线程发来消息,处理其他事件)
    在子线程中开启一个定时器
    在子线程中进行一些长期监控

可以控制定时器在特定模式下执行
可以让某些事件(行为、任务)在特定模式下执行
可以添加Observer监听RunLoop的状态,比如监听点击事件的处理(在所有点击事件之前做一些事情)

所有参考链接：

1、ibireme

2、百度大神

3、视频-runloop线下分享

4、RunLoop实际应用

5、官方文档

6、CFRunLoop.c