dailyLearning -- runLoop
- runLoop
- runLoop 对外的接口及相关类
- runLoop 内部逻辑
- runLoop 可以做啥
- runLoop 的实际应用
一、runLoop
1.runLoop 概念
Runloop多线程开发的中的一个概念,当然也可以向Runloop中提交一些任务;监听一些事件;属于多线程编程的一部分,合理的使用Runloop对App的性能提高有很大帮助;
RunLoop是与线程相关的基础功能,RunLoop是用于调度工作,并协调接收传入事件的事件处理循环;RunLoop的目标是让线程有任务时工作,没有任务处理时休眠;
runloop 实际上是一个对象, 这个对象在循环中用来处理程序运行过程中出现的各种事件(比如说触摸事件, UI 刷新事件,定时事件, Selector 消息事件), 从而保证程序的持续运行; 而且在空闲时进入休眠状态, 从而节省 CPU 资源,提高程序性能;
runLoop 的关键点在于: 如何管理事件/消息,如何让线程在没有处理消息时休眠以避免资源占用、在有消息到来时立刻被唤醒;
2.RunLoop基本作用
- 保持程序持续运行
程序一启动就会开一个主线程, 同时会创建一个和主线程对应的 RunLoop, 来保证线程不会被销毁, 也就保证了程序的持续运行;- 处理 App 中的各种事件
比如:触摸事件, 定时器事件, Selector 消息事件等;- 节省 CPU 资源,提高程序性能
程序运行起来时, 当什么操作都没有做的时候, runloop 就会告诉 CPU, 现在没有事儿做,我要去睡觉, 这时 CPU 就会将其资源释放出来,去做其他的事情, 当有事做的时候 runloop 就会立马醒来去做事情;
我们先通过 API 内一张图片来简单看一下 runloop 内部运行原理:
通过上图可以看出, runloop 在跑圈的过程中, 当接收到input sources或者 timer sources 时就会交给对应的处理方去处理; 当没有事件消息传入的时候, runloop 就会睡去;
3.runLoop 与线程
在iOS开发中,每个线程(NSThread)在创建的时候都会自动绑定一个Runloop;主线程的Runloop在App启动的时候自动运行;自己创建的线程;要写代码来启动Runloop,提交任务,接受事件;
a. runLoop 和线程之间的关系:
- 每天线程都有唯一的一个与之对应的 runLoop 对象;
- 主线程的 runLoop 已经自动创建好了, 子线程的 runLoop 需要主动创建;
- runLoop 在第一次获取时创建, 在线程结束时销毁;
b. 苹果不允许直接创建 RunLoop;它只提供了两个自动获取的函数：CFRunLoopGetMain() 和 CFRunLoopGetCurrent(); 这两个函数内部的逻辑大概是下面这样:
/// 全局的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 之间是一一对应的,其关系是保存在一个全局的Dictionary 里;线程刚创建时并没有 RunLoop,如果你不主动获取,那它一直都不会有;RunLoop 的创建是发生在第一次获取时,RunLoop 的销毁是发生在线程结束时;你只能在一个线程的内部获取其 RunLoop（主线程除外）
二、runLoop 对外的接口及相关类
1. runLoop 对象的获取
//Foundation
[NSRunLoop currentRunLoop]; // 获得当前线程的RunLoop对象
[NSRunLoop mainRunLoop]; // 获得主线程的RunLoop对象
//Core Foundation
CFRunLoopGetCurrent(); // 获得当前线程的RunLoop对象
CFRunLoopGetMain(); // 获得主线程的RunLoop对象
2. 相关类
在 CoreFoundation 中关于 runLoop 有 5 个类:
CFRunLoopRef //获得当前RunLoop和主RunLoop
CFRunLoopModeRef //运行模式,只能选择一种,在不同模式中做不同的操作
CFRunLoopSourceRef //事件源,输入源
CFRunLoopTimerRef //定时器时间
CFRunLoopObserverRef //观察者
其中 CFRunLoopModeRef 类并没有对外暴露, 只是通过 CFRunLoopRef 的接口进行了封装, 关系如下:
RunLoop_0.png
一个 runLoop 包含若干个
mode, 每个 mode又包含若干个 Source/Timer/Observer, 每次调用 runLoop 的主函数时, 只能指定其中一个 mode, 这个 mode 被称作CurrentMode, 如果需要切换 mode, 只能退出 loop, 再重新指定一个 mode 进入, 这样做主要是为了分隔开不同组的Source.Timer/Observer, 让其互不影响;
CFRunLoopSourceRef 是事件产生的地方;
Source 有两个版本: Source0 和 Source1;
Source0只包含了一个回调(函数指针), 它并不能主动触发事件, 使用时, 你需要先调用CFRunLoopSourceSignal (source), 将这个 Source 标记为待处理, 然后手动调用 CGRunLoopWakeUp (runLoop)来唤醒 runLoop, 让其处理这个事件;
Source1 包含了一个 mach_port 和一个回调(函数指针), 被用于通过内核和其他线程相互发送消息, 这种 Source 能主动唤醒 runLoop 的线程, 其原理下面会提及;
当有事件产生, RunLoop 处于休眠状态，则唤醒它处理事件，简单来说就是 "睡你xx，起来嗨! "
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), // 即将进入休眠
kCFRunLoopAfterWaiting = (1UL << 6), // 刚从休眠中唤醒
kCFRunLoopExit = (1UL << 7), // 即将退出Loop
};
上面的 Source/Timer/Observe 统称为mode item, 一个item可以被同时加入多个mode, 但是一个item呗重复加入同一个 mode 时, 是不会有效果的, 如果一个mode中一个 item都没有, runLoop 会直接退出, 不再进入循环;
3. 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
...
};
这里有个概念叫:“CommonModes”: 一个 mode可以将自己标记为 “Common” 属性 (通过将其modeName 添加到 runLoop 的“commonModes” 中); 每当 runLoop 的内容发生变化时, runLoop 都会自动将_commonModeItems里的 Source/Timer/Observer同步到具有 “Common” 标记的所有 mode 里;
应用场景举例:
主线程的 runLoop 里有两个预置的 mode:kCFRunLoopDefaultMode和UITrackingRunLoopMode, 这两个 mode 都已经被标记为 “Common” 属性;DefaultMode 是 App 平时所处的状态, TrackingMode 是追踪 ScrollView滑动时的状态; 当你创建一个 Timer 并加到 DefaultMode时,timer 会得到重复回调, 但此时滑动一个 ScrollView, runLoop 会将 mode 切换为 TrackingMode, 这是timer就不会被回调, 并且也不会影响到滑动操作;
但是, 有时我们需要一个timer, 在两个mode 中都能得到回调,
一种办法是: 将这个timer分别加入到两个mode;
另一种办法: 就是讲timer 加入到顶层的runLoop 的 “commonModeItems”中,“commonModeItems” 被 runLoop 自动更新到所有具有“Common”属性的 mode 中 去;
CFRunLoop 对外暴露的管理 mode 接口只有两个:
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 会自动帮我们创建对应的 CGRunLoopModeRef, 对于一个 runLoop 来说, 其内部的 mode 只能增加不能删除;
苹果公开提供的 mode 有两个:kCFRunLoopDefaultMode和 UITrackingRunLoopMode, 我们可以用这两个 mode name来操作其对应的 mode;
同时苹果还提供了一个操作 “Common” 标记的字符串: kCFRunLoopCommonModes (NSRunLoopCommonModes), 我们可以用这个字符串来操作 Common Items, 或者标记一个 mode 为 “Common”; 使用时注意区分这个字符串和其他mode name;
三、runLoop 内部逻辑
根据苹果在文档里的说明,RunLoop 内部的逻辑大致如下:
RunLoop_1.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 实现的功能
我们可以看一下 App 启动后 runLoop 的状态:
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),
}
}
}
可以看到, 系统默认注册了 5 个 mode:
-
kCFRunLoopDefaultMode:App 默认的 mode, 通常主线程在这个 mode 下运行; -
UITrackingRunLoopMode:界面追踪 mode, 用于 ScrollView 追踪触摸滑动, 保证界面滑动时不受其他 mode 影响; -
UIInitializationRunLoopMode:在程序刚启动时, 进入的第一个 mode, 启动完成后就不再使用; -
GSEventReceiveRunLoopMode:接收系统事件的内部 mode, 通常用不到; -
kCFRunLoopCommonModes:这是个占位 mode, 没有实际作用;
当 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);
}
1. 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 了;
2. 事件响应
苹果注册了一个 Source1 (基于 mach port 的) 用来接收系统事件, 其回调函数为_IOHIDEventSystenClientQueueCallback();
当一个硬件事件 (触摸/锁屏/摇晃等) 发生后, 首先由 IOKit.framework 生成一个 IOHIDEvent 事件并由 SpringBoard接收, 这个过程的详细情况可以参考这里; SpringBoard只接收按键(锁屏/静音等), 触摸,加速,接近传感器等几种 event, 随后用 mach port 转发给需要的 App 进程; 随后苹果注册的那个 Source1 就会触发回调, 并调用 _UIApplicationHandleEventQueu()进行应用内部的分发;
_UIApplicationHandleEventQueue()会把IOHIDEvent 处理并包装成 UIEvent进行处理或者分发, 其中包括识别 UIGesture / 处理屏幕旋转 / 发送给 UIWindow 等; 通常事件比如 UIButton 点击, touchsBegin / Move / End / Cancel 事件都是在这个回调中完成的;
3. 手势识别
当上面的_UIApplicationHandleEventQueue()识别了一个手势时, 其首先会调用 Cancel 将当前的 touchsBegin / Move / End 系列回调打断, 随后系统将对应的UIGestureRecognizer标记为待处理;
苹果注册了一个 Observer 检测 BeforeWaiting (Loop 即将进入休眠) 事件, 这个 Observer 的回调函数是 _UIGestureRecognizerUpdateObserver(), 其内部会获取所有刚被标记为待处理的 GestureRecognizer, 并执行 GestureRecognizer 的回调;
当有 UIGestureRecognizer 的变化 (创建/销毁/状态改变) 时, 这个回调都会进行相应的处理;
4. 界面更新
当在操作 UI 时, 比如改变了 Frame, 更新了 UIView / CALayer 的层次时, 或者手动调用了 UIView /CALayer 的 setNeedLayout / setNeedDisplay 方法后, 这个 UIView /CALayer 就被标记为待处理, 并被提交到一个全局的容器去;
苹果注册了一个 Observer 监听 BeforeWaiting (即将进入休眠) 和 Exit (即将推出 Loop) 事件, 回调去执行一个很长的函数:
_ZN2CA11Transaction17observer_callbackEP19_CFRunLoopObserverPv();这个函数里会遍历所有待处理的 UIView /CALayer 以执行实际的绘制和调整, 并更新 UI 界面;
这个函数内部的调用栈大概是这样的:
_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];
5. 定时器
NSTimer 其实局势 CFRunLoopTimerRef, 他们之间数据类型是可以相互转换的, 一个 NSTimer 注册到 runLoop 后, runLoop 会为其重复的时间点注册好事件, 例如: 10:00, 10:10, 10:20 这几个时间点, runLoop 为了节省资源, 并不会在非常准确的时间点回调这个 Timer , timer 有个属性叫做 Tolerance (宽容度), 表示了当时间点到后, 容许有多少最大误差;
如果某个时间点被错过了, 例如执行了一个很长的任务, 则那个时间点的回调也会跳过去, 不会延后执行; 就比如等公交, 如果10:00 时, 我忙着玩手机错过了那个点的公交, 那我只能等 10:20 这一趟了
CADisplayLink是一个和屏幕刷新频率一致的定时器 (但实际上实现原理更复杂, 和 NSTimer 并不一样, 其内部实际是操作了一个 Source); 如果两次屏幕刷新之间执行了一个长任务, 那其中就会有一帧被跳过去 (和 NSTimer 相似) , 造成界面卡顿的感觉; 在快速滑动 ScrollView 时, 即使一帧的卡顿也会让用户有所察觉; Facebook 开源的 AsyncDisplayLink 就是为了解决界面卡顿的问题, 其内部也用到了 runLoop;
6. PerformSelector
当调用 NSObject 的 performSelector:afterDelay: 后, 实际上其内部会创建一个 timer 并添加到当前线程的 runLoop 中, 所以如果当前线程没有 runLoop, 则这个方法会失效;
当调用performSelector:onThread: 时, 实际上其会创建一个 timer 加到对应的线程去, 同样的, 如果对应线程没有 runLoop 该方法也会失效;
7. 关于网络请求
iOS 中, 关于网络请求的接口自下至上有如下几层:
CFSocket
CFNetwork ->ASIHttpRequest
NSURLConnection ->AFNetworking
NSURLSession ->AFNetworking2, Alamofire
CFSocket 是最底层的接口, 只负责 socket 通信;
CFNetwork 是基于 CFSocket 等接口的上层封装, ASIHttpRequest 工作于这一层;
NSURLConnection 是基于 CFNetwork 的更高层的封装, 提供面向对象的接口, AFNetworking 工作于这一层;
NSURLSession 是 iOS7中新增的接口, 表面上和 NSURLConnection 并列的, 但底层仍然用到了 NSURLConnection 的部分功能 (比如: com.apple.NSURLConnectionLoader 线程);
通常使用 NSURLConnection 时, 我们会传入一个 delegate, 当调用了 [connection start]; 后, 这个delegate 就会不停接收到事件回调; 实际上start 这个函数的内部会获取 CurrentRunLoop, 然后在其中的 DefaultMode添加了 4 个 Source0(即需要手动触发的 Source); CFMultiplexerSource是负责各种 delegate 回调的, CFHTTPCookieStorage 是处理各种Cookie 的;
当开始网络传输时, 我们可以看到 NSURLConnection创建了两个新线程:
com.apple.NSURLConnectionLoader 和 com.apple.CFSocket.private; 其中 CFSocket线程是处理底层socket连接的, NSURLConnectionLoader这个线程内部会使用 runLoop 来接收底层 socket 的事件, 并通过之前添加的Source0 通知到上层的 delegate;
RunLoop_network.png
NSURLConnectionLoader 中的 runLoop 通过一些基于mach port 的 Source 接收来自底层 CFSocket 的通知; 当收到通知后, 其会在合适的时机向 CFMultiplexerSource 等 Source0 发送通知, 同时唤醒 delegate 线程的 runLoop 来让其处理这些通知; CFMultiplexerSource 会在 delegate 线程的 runLoop 对 delegate 执行实际的回调;
五、runLoop 的实际应用
1. AFNetworkinng
AFURLConnectionOperation这个类是基于 NSURLConnection 构建的, 其希望能在后台线程接收 delegate 回调; 为此 AFNetworking 单独创建了一个线程, 并在这个线程中启动了一个 runLoop:
+ (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;
}
runLoop 启动前内部必须 要有至少一个 Source / Timer / Observer , 所以 AFNetworking 在[runLoop run]; 之前创建了一个新的 NSMachPort 添加进去了; 通常情况下, 调用者需要持有这个 NSMachPort (mach_port) 并在外部线程通过这个 port 发送到 loop 内; 但此处添加 port 只是为了让 runLoop 不至于退出, 并没有用于实际的发送消息;
- (void)start {
[self.lock lock];
if ([self isCancelled]) {
[self performSelector:@selector(cancelConnection) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
} else if ([self isReady]) {
self.state = AFOperationExecutingState;
[self performSelector:@selector(operationDidStart) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
}
[self.lock unlock];
}
当需要这个后台线程执行任务时, AFNetworking 通过调用[NSObject performSelector:onThread:]; 将这个任务扔到了后台线程的 runLoop 中;
参考资料：
