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个类的对应关系大概是:
下面具体介绍这个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 = <CFBasicHash 0x7fdaa0d00ae0 [0x1084b57b0]>{type = mutable set, count = 2, entries =>
0 : <CFString 0x10939f950 [0x1084b57b0]>{contents = "UITrackingRunLoopMode"}
2 : <CFString 0x1084d5b40 [0x1084b57b0]>{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 种状态里面,对应着不同的处理。
网上的参考逻辑图如下:
其内部代码如下:(没有耐心的话,可以跳过不看)
> /// 用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] 的结果中我们可以看到与自动释放池相关的:
<CFRunLoopObserver>{activities = 0x1, callout =
_wrapRunLoopWithAutoreleasePoolHandler}<CFRunLoopObserver>{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 的打印结果我们还可以看到
<CFRunLoopObserver >{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:
五、第三方库 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?
从字面上看:运行循环、跑圈
其实它内部就是do-while循环,在这个循环内部不断的处理各种任务(比如Source、Timer、Observer)
一个线程对应一个RunLoop,主线程的RunLoop默认已经启动,子线程的RunLoop需要手动启动(调用run方法)
RunLoop只能选择一个Mode启动,如果当前Mode中没有任何Soure、Timer、Observer,那么就直接退出RunLoop
在开发中如何使用RunLoop?什么应用场景?
开启一个常驻线程(让一个子线程不进入消亡状态,等待其他线程发来消息,处理其他事件)
在子线程中开启一个定时器
在子线程中进行一些长期监控
可以控制定时器在特定模式下执行
可以让某些事件(行为、任务)在特定模式下执行
可以添加Observer监听RunLoop的状态,比如监听点击事件的处理(在所有点击事件之前做一些事情)
所有参考链接:
1、ibireme
2、百度大神
5、官方文档