一、runloop 简介
RunLoop是通过内部维护的 事件循环(Event Loop) 来对 事件/消息 进行管理的一个对象。
- 没有消息处理时，休眠已避免资源占用，由用户态切换到内核态。
- 有消息需要处理时，立刻被唤醒，由内核态切换到用户态。
image.png
runloop的官方文档在thread篇章Run Loops，也就从侧面说明了runloop是与线程息息相关的。
1.1 runloop 输入源与处理机制
官方有如下一张图：
`runloop`与`source`结构
线程的输入源:
Port Source：基于端口的输入源。Custom Source：自定义输入源performSelector：Cocoa执行Selector的源。Timer Source：定时源。
线程针对输入源的处理机制：
handlePort：处理基于端口的输入源。customSrc：处理用户自定义输入源。mySelector：处理Selector的源。timerFired：处理定时源。
有以下案例：
- (void)sourcesTest {
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(notificationAction:) name:@"notificationTest" object:nil];
//__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
[NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
NSLog(@"timer action");
}];
[self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:1.0];
//
// __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__
// __FBSSERIALQUEUE_IS_CALLING_OUT_TO_A_BLOCK__
void (^block)(void) = ^{
NSLog(@"block action");
};
block();
// __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"main queue");
});
}
//__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
- (void)performSelectorAction {
NSLog(@"timer action");
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
// __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__
NSLog(@"touches action");
[[NSNotificationCenter defaultCenter] postNotificationName:@"notificationTest" object:nil];
}
- (void)notificationAction:(NSNotification *)noti {
// __CFNOTIFICATIONCENTER_IS_CALLING_OUT_TO_AN_OBSERVER__
NSLog(@"notification action");
}
timer与performSelector对应的回调都是__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__：
image.png
后续的调用函数不同。
block对应__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__：
image.png
不过后续调用到了__FBSSERIALQUEUE_IS_CALLING_OUT_TO_A_BLOCK__。
主线程对应__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__:
image.png
系统触摸事件对应__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__：
image.png
通知事件对应__CFNOTIFICATIONCENTER_IS_CALLING_OUT_TO_AN_OBSERVER__：
image.png
小结：
- 调用
timer:__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__。NSTimer与performSelector都属于timer。 - 响应
source0:__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__。block，系统触摸事件（触摸事件先交给source1唤醒runloop然后交给source0处理）。 - 响应
source1:__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__。处理系统事件。 GCD主队列:__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__。observer源:__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__。通知。
二、CFRunloop 的使用
2.1 CFRunLoopMode 验证
- (void)scrollViewDidScroll:(UIScrollView *)scrollView{
NSLog(@"scrollViewDidScroll: %@",[NSRunLoop currentRunLoop].currentMode);
}
- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
NSLog(@"scrollViewDidEndDecelerating: %@",[NSRunLoop currentRunLoop].currentMode);
}
- (void)runloopModeTest {
//获取当前runloop
CFRunLoopRef runloop = CFRunLoopGetCurrent();
//获取当前mode
CFRunLoopMode runloopMode = CFRunLoopCopyCurrentMode(runloop);
NSLog(@"runloopMode: %@",runloopMode);
//获取所有 mode
CFArrayRef modeArray= CFRunLoopCopyAllModes(runloop);
NSLog(@"modeArray: %@",modeArray);
NSTimer *timer = [NSTimer timerWithTimeInterval:3 repeats:YES block:^(NSTimer * _Nonnull timer) {
NSLog(@"timerWithTimeInterval mode: %@",[[NSRunLoop currentRunLoop] currentMode]);
}];
//timer 添加到 runloop 的 commonModes
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
}
滚动页面输出：
runloopMode: kCFRunLoopDefaultMode
//主线程runloop modes
modeArray: (
UITrackingRunLoopMode,
GSEventReceiveRunLoopMode,
kCFRunLoopDefaultMode,
kCFRunLoopCommonModes
)
//页面静止
timerWithTimeInterval mode: kCFRunLoopDefaultMode
//页面滚动
scrollViewDidScroll: UITrackingRunLoopMode
scrollViewDidScroll: UITrackingRunLoopMode
timerWithTimeInterval mode: UITrackingRunLoopMode
scrollViewDidScroll: UITrackingRunLoopMode
scrollViewDidEndDecelerating: UITrackingRunLoopMode
//页面静止
timerWithTimeInterval mode: kCFRunLoopDefaultMode
页面滚动过程中处于UITrackingRunLoopMode，静止状态处于kCFRunLoopDefaultMode。
2.2 CFRunLoopTimerRef
@interface ViewController () {
CFRunLoopTimerRef timerRef;
}
@end
- (void)cfTimerTest {
/** CFRunLoopTimerContext timer 上下文
version: 版本
info: 传递参数
void *(*retain)(const void *info): retain 操作
void (*release)(const void *info): release 操作
(*copyDescription)(const void *info): copy 描述信息
*/
CFRunLoopTimerContext context = {
0,
((__bridge void *)self),
NULL,
NULL,
NULL
};
//获取当前 runloop
CFRunLoopRef runloop = CFRunLoopGetCurrent();
/** CFRunLoopTimerCreate 创建 timer
allocator: 用于分配对象的内存
fireDate：在什么是触发 (距离现在)
interval: 每隔多少时间触发一次
flags: 未来参数
order: CFRunLoopObserver的优先级 当在Runloop同一运行阶段中有多个CFRunLoopObserver 正常情况下使用0
callout: 回调,比如触发事件。
context:上下文记录信息
*/
//创建timer
timerRef = CFRunLoopTimerCreate(kCFAllocatorDefault, 0, 3, 0, 0, _runLoopTimerCallBack, &context);
CFRunLoopAddTimer(runloop, timerRef, kCFRunLoopCommonModes);
}
// CFRunLoopTimerCallBack typedef void (*CFRunLoopTimerCallBack)(CFRunLoopTimerRef timer, void *info);
void _runLoopTimerCallBack(CFRunLoopTimerRef timer, void *info) {// info 为 context 中的 info
NSLog(@"_runLoopTimerCallBack:%@,%@,%@",timer,info,[NSRunLoop currentRunLoop].currentMode);
}
- (void)dealloc {
[self invalidCFTimer];
}
// 移除 timer
- (void)invalidCFTimer {
CFRunLoopRef runloop = CFRunLoopGetCurrent();
if (timerRef && CFRunLoopContainsTimer(runloop, timerRef, kCFRunLoopCommonModes)) {
CFRunLoopRemoveTimer(runloop, timerRef, kCFRunLoopCommonModes);
}
}
CFRunLoopTimerContext创建上下文用于传递参数，info就是最终callback回调中的info信息。CFRunLoopTimerCreate主要是回调函数以及时间间隔的设置。dealloc中需要移除timer，不释放有可能crash，不会造成循环引用。需要判断timer是否存在以及是否在要移除的runloop中。
2.3 CFRunLoopObserverRef
CFRunLoopObserverRef observerRef;
- (void)cfObserverTest {
//context 与 timer 的相同
CFRunLoopObserverContext context = {
0,
((__bridge void *)self),
NULL,
NULL,
NULL
};
CFRunLoopRef runloop = CFRunLoopGetCurrent();
/**
allocator: 用于分配对象的内存
activities: 要关注的事件，与 runloop 循环中处理的状态一致。
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
kCFRunLoopEntry = (1UL << 0),
kCFRunLoopBeforeTimers = (1UL << 1),
kCFRunLoopBeforeSources = (1UL << 2),
kCFRunLoopBeforeWaiting = (1UL << 5),
kCFRunLoopAfterWaiting = (1UL << 6),
kCFRunLoopExit = (1UL << 7),
kCFRunLoopAllActivities = 0x0FFFFFFFU
};
repeats: CFRunLoopObserver 是否循环调用，不循环只会有一次回调。NO的情况下 CFRunLoopObserverRef 会自动移除。
order: CFRunLoopObserver 的优先级 当在Runloop同一运行阶段中有多个 CFRunLoopObserver 正常情况下使用 0
callout: 回调
context: 上下文记录信息
*/
observerRef = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, NO, 0, _runLoopObserverCallBack, &context);
CFRunLoopAddObserver(runloop, observerRef, kCFRunLoopDefaultMode);
}
//typedef void (*CFRunLoopObserverCallBack)(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info);
void _runLoopObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info){
NSLog(@"observerCallBack: %@,%lu,%@",observer,activity,info);
}
- (void)removeRunloopObserver {
CFRunLoopRef runloop = CFRunLoopGetCurrent();
if (observerRef && CFRunLoopContainsObserver(runloop, observerRef, kCFRunLoopDefaultMode)) {
CFRunLoopRemoveObserver(runloop, observerRef, kCFRunLoopDefaultMode);
}
}
- (void)dealloc {
[self removeRunloopObserver];
}
CFRunLoopObserverContext与CFRunLoopTimerContext结构相同。CFRunLoopObserverCreate可以只监听某些状态。repeats控制是否循环调用，不循环的情况下回调只会调用一次（所有状态假加起来），并且会自动从runloop中移除。
可以通过
observer进行卡顿检测相关逻辑处理。
2.4 CFRunLoopSourceRef
2.4.1 source0
- (void)source0Test {
/**
typedef struct {
CFIndex version; //版本
void * info; //回调info信息
const void *(*retain)(const void *info);
void (*release)(const void *info);
CFStringRef (*copyDescription)(const void *info);
Boolean (*equal)(const void *info1, const void *info2); //判等
CFHashCode (*hash)(const void *info); //hash code
void (*schedule)(void *info, CFRunLoopRef rl, CFRunLoopMode mode); //准备代发回调
void (*cancel)(void *info, CFRunLoopRef rl, CFRunLoopMode mode); //取消回调
void (*perform)(void *info); // 执行回调
} CFRunLoopSourceContext;
*/
CFRunLoopSourceContext context = {
0,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
schedule,
cancel,
perform,
};
/**
allocator: 传递NULL或 kCFAllocatorDefault 以使用当前默认分配器。
order: 优先级索引，指示处理运行循环源的顺序。这里传0为了的就是自主回调
context: 为运行循环源保存上下文信息的结构
*/
//创建source
CFRunLoopSourceRef source0 = CFRunLoopSourceCreate(CFAllocatorGetDefault(), 0, &context);
CFRunLoopRef runloop = CFRunLoopGetCurrent();
//source 指定了 runloop 与 mode 就进去就绪状态了。schedule 调用
CFRunLoopAddSource(runloop, source0, kCFRunLoopDefaultMode);
//一个执行信号 perform
CFRunLoopSourceSignal(source0);
//这里加延迟为了让 perform 有机会执行。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
//唤醒 runloop 防止沉睡状态
CFRunLoopWakeUp(runloop);
//取消移除 source，执行 cancel 回调
CFRunLoopRemoveSource(runloop, source0, kCFRunLoopDefaultMode);
});
}
void schedule(void *info, CFRunLoopRef rl, CFRunLoopMode mode){
NSLog(@"schedule 准备代发");
}
void perform(void *info){
NSLog(@"source0 执行");
}
void cancel(void *info, CFRunLoopRef rl, CFRunLoopMode mode){
NSLog(@"source0 cancel");
}
输出：
schedule 准备代发
source0 执行
source0 cancel
CFRunLoopSourceContext相比timer和observer多了判等以及哈希相关计算外。更重要的是schedule 、cancel 、perform 3个回调。CFRunLoopSourceCreate相比就比较简单了，重要参数是context。
2.4.2 source1 线程间通信
@interface ViewController ()<NSPortDelegate>
@property (nonatomic, strong) NSPort* subThreadPort;
@property (nonatomic, strong) NSPort* mainThreadPort;
@end
- (void)source1Test {
self.mainThreadPort = [NSPort port];
self.mainThreadPort.delegate = self;
// port - source1 -- runloop
[[NSRunLoop currentRunLoop] addPort:self.mainThreadPort forMode:NSDefaultRunLoopMode];
[self task];
}
- (void)task {
__weak typeof(self) weakSelf = self;
NSThread *thread = [[NSThread alloc] initWithBlock:^{
NSLog(@"initWithBlock:%@", [NSThread currentThread]); // 5
weakSelf.subThreadPort = [NSPort port];
weakSelf.subThreadPort.delegate = weakSelf;
[[NSRunLoop currentRunLoop] addPort:weakSelf.subThreadPort forMode:NSDefaultRunLoopMode];
[[NSRunLoop currentRunLoop] run];
}];
[thread start];
}
#pragma mark --- NSPortDelegate ---
- (void)handlePortMessage:(id)message {//NSPortMessage 是macos中的类。
NSLog(@"handlePortMessage: %@, thread:%@",message,[NSThread currentThread]);
NSArray *componentsArray = [message valueForKey:@"components"];
for (NSInteger i = 0; i < componentsArray.count; i++) {
NSData *data = componentsArray[i];
NSString *dataStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
NSLog(@"dataStr: %@",dataStr);
}
//runtime 获取ivar。
// unsigned int count = 0;
// Ivar *ivars = class_copyIvarList([message class], &count);
// for (int i = 0; i < count; i++) {
// NSString *name = [NSString stringWithUTF8String:ivar_getName(ivars[i])];
// NSLog(@"data: %@",name);
// }
sleep(1);
if (![[NSThread currentThread] isMainThread]) {
NSMutableArray *components = [NSMutableArray array];
//必须转成data，否则会被忽略。
NSData *data = [@"hotpot" dataUsingEncoding:NSUTF8StringEncoding];
[components addObject:data];
//从 subport 给 mainport 发送数据。
NSLog(@"mainport send data to subport");
[self.mainThreadPort sendBeforeDate:[NSDate date] components:components from:self.subThreadPort reserved:0];
}
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
NSMutableArray* components = [NSMutableArray array];
NSData* data = [@"cat" dataUsingEncoding:NSUTF8StringEncoding];
[components addObject:data];
//从 mainport 给 subThreadPort 发送数据。
NSLog(@"subport send data to mainport");
[self.subThreadPort sendBeforeDate:[NSDate date] components:components from:self.mainThreadPort reserved:0];
}
输出：
image.png
mainThreadPort是在主线程创建添加进runloop的，subThreadPort是在子线程创建添加进runloop的。handlePortMessage :为NSPortDelegate的代理方法。参数NSPortMessage是定义在macOS中的。iOS没有该类的定义。- 通过
sendBeforeDate:components:from: reserved :进行线程间数据传递。从from port给调用方port线程发送数据。 - 数据需要包装为
NSData才有效。
NSPortMessage定义在macOS中：
image.png
三、runloop 结构
既然runloop是一个事件循环，那么它与普通的循环有什么区别呢？
普通循环：
image.png
runloop循环：
image.png
那么可以得到以下结论：
runloop能保持程序的持续运行。- 处理
APP中的各种事件(触摸、定时器、performSelector)。 - 节省
cpu资源、提高程序的性能。有休眠和唤醒状态。
3.1 runloop 源码定位
那么runloop是怎么做到的呢？
通常我们会通过NSRunLoop去获取当前的runloop：
[NSRunLoop currentRunLoop];
定义如下：
@property (class, readonly, strong) NSRunLoop *currentRunLoop;
给currentRunLoop下符号断点：
image.png
可以看到NSRunLoop是对CFRunLoop的封装。
image.png
通过之前的分析已经定位到了runloop是在CoreFoundation中的 CoreFoundation源码。正好CoreFoundation开源了CFRunLoop：
image.png
3.2 CFRunLoopRun
//CFRunLoopRun 是对 do...while 的封装
void CFRunLoopRun(void) { /* DOES CALLOUT */
int32_t result;
do {
//run
result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
CHECK_FOR_FORK();
//不是完成或者结束
} while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}
runloop底层是对do...while的封装。- 当状态为完成或者结束后退出循环。
那么核心逻辑就在CFRunLoopRunSpecific中。还有一个疑问是runloop可以休眠，那么它是如何实现的呢？
3.3 runloop 数据结构
要了解runloop的实现原理，首先要清楚它的数据结构。
3.3.1 线程与runloop的关系
CFRunLoopRunSpecific的第一个参数是CFRunLoopGetCurrent()：
CFRunLoopRef CFRunLoopGetCurrent(void) {
CHECK_FOR_FORK();
//通过 key-value 形式获取 CFRunLoopRef
CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
if (rl) return rl;
//没有缓存通过线程获取
return _CFRunLoopGet0(pthread_self());
}
- 去缓存中获取
CFRunLoopRef。 - 缓存中不存在通过线程去获取。
_CFRunLoopGet0
// should only be called by Foundation
// t==0 is a synonym for "main thread" that always works
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
//没有传 pthread_t，则默认为主线程
if (pthread_equal(t, kNilPthreadT)) {
t = pthread_main_thread_np();
}
__CFLock(&loopsLock);
if (!__CFRunLoops) {
__CFUnlock(&loopsLock);
//创建可变字典
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
//通过 主线程 创建 mainLoop
CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
// 进行绑定，存储 thread（key） - runloop（value）: dict[@"pthread_main_thread_np"] = mainLoop
CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
CFRelease(dict);
}
CFRelease(mainLoop);
__CFLock(&loopsLock);
}
//通过 thread 获取 runloop（非main runloop）
CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
__CFUnlock(&loopsLock);
if (!loop) {//runloop不存在
//创建runloop
CFRunLoopRef newLoop = __CFRunLoopCreate(t);
__CFLock(&loopsLock);
loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
if (!loop) {
//存储 runloop
CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
loop = newLoop;
}
// don't release run loops inside the loopsLock, because CFRunLoopDeallocate may end up taking it
__CFUnlock(&loopsLock);
CFRelease(newLoop);
}
if (pthread_equal(t, pthread_self())) {
_CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
}
}
return loop;
}
runloop与线程是一一对应的，每个runloop对应一个线程。线程并不一定有runloop，在有的情况下是一一对应的。runloop底层是存储在可变字典中的，key为线程，value为runloop。runloop是CFRunLoopRef类型，通过__CFRunLoopCreate创建。
image.png
3.3.2 CFRunLoopRef
image.png
可以看到在创建CFRunLoopRef的时候有对应的modes、items、_pthread。并且创建完成后调用__CFRunLoopFindMode去找mode。
CFRunLoopRef的定义如下：
typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoop * CFRunLoopRef;
实际上底层它是__CFRunLoop类型：
struct __CFRunLoop {
CFRuntimeBase _base;
pthread_mutex_t _lock; /* locked for accessing mode list */
__CFPort _wakeUpPort; // used for CFRunLoopWakeUp
Boolean _unused;
volatile _per_run_data *_perRunData; // reset for runs of the run loop
pthread_t _pthread;//线程
uint32_t _winthread;
CFMutableSetRef _commonModes;
CFMutableSetRef _commonModeItems;//集合类型 Items
CFRunLoopModeRef _currentMode;
CFMutableSetRef _modes;//集合类型 Modes
struct _block_item *_blocks_head;
struct _block_item *_blocks_tail;
CFAbsoluteTime _runTime;
CFAbsoluteTime _sleepTime;
CFTypeRef _counterpart;
};
- 一个
runloop对应多个modes以及items。
对于timer而言:
[[NSRunLoop currentRunLoop] addTimer:<#(nonnull NSTimer *)#> forMode:<#(nonnull NSRunLoopMode)#>];
显然它是要依赖mode的。
CFRunLoopMode
struct __CFRunLoopMode {
CFRuntimeBase _base;
pthread_mutex_t _lock; /* must have the run loop locked before locking this */
CFStringRef _name;
Boolean _stopped;
char _padding[3];
CFMutableSetRef _sources0;//set source0
CFMutableSetRef _sources1;//set source1
CFMutableArrayRef _observers;//array observe
CFMutableArrayRef _timers;//array times
CFMutableDictionaryRef _portToV1SourceMap;//dic port
__CFPortSet _portSet;
CFIndex _observerMask;
#if USE_DISPATCH_SOURCE_FOR_TIMERS
dispatch_source_t _timerSource;
dispatch_queue_t _queue;
Boolean _timerFired; // set to true by the source when a timer has fired
Boolean _dispatchTimerArmed;
#endif
#if USE_MK_TIMER_TOO
mach_port_t _timerPort;
Boolean _mkTimerArmed;
#endif
#if DEPLOYMENT_TARGET_WINDOWS
DWORD _msgQMask;
void (*_msgPump)(void);
#endif
uint64_t _timerSoftDeadline; /* TSR */
uint64_t _timerHardDeadline; /* TSR */
};
而一个mode下又对应多个items(source0、source1、timers、observers)，所以就有如下关系：
image.png
1个runloop对应1个线程。1个runloop对应多个mode。1个mode对应多个source、timer、observer。
3.3.3 RunLoop Modes
既然有多种mode，那么都有哪些呢？
源码中有如下定义：
CF_EXPORT const CFRunLoopMode kCFRunLoopDefaultMode;
CF_EXPORT const CFRunLoopMode kCFRunLoopCommonModes;
它们对应Foundation中的：
FOUNDATION_EXPORT NSRunLoopMode const NSDefaultRunLoopMode;
FOUNDATION_EXPORT NSRunLoopMode const NSRunLoopCommonModes ;
我们都清楚在页面滚动的时候有一个UITrackingRunLoopMode：
UIKIT_EXTERN NSRunLoopMode const UITrackingRunLoopMode;
除了以上3种mode还有两个私有mode：
UIInitializationRunLoopMode
GSEventReceiveRunLoopMode
当RunLoop运行在Mode1上时，是无法接受处理Mode2或Mode3上的Source、Timer、Observer事件的。
kCFRunLoopDefaultMode/NSDefaultRunLoopMode：默认模式，主线程是在这个运行模式下运行。kCFRunLoopCommonModes/NSRunLoopCommonModes：伪模式，不是一种真正的运行模式，是同步Source/Timer/Observer到多个Mode中。UITrackingRunLoopMode：跟踪用户交互事件（用于ScrollView追踪触摸滑动，保证界面滑动时不受其他Mode影响）。对于macOS对应NSEventTrackingRunLoopModeUIInitializationRunLoopMode：在刚启动App时第进入的第一个Mode，启动完成后就不再使用。GSEventReceiveRunLoopMode：接受系统内部事件，通常用不到。
四、runloop 事务处理
4.1 timer 事务处理
以timer为例，将timer加入到runloop中：
NSTimer *timer = [NSTimer timerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
NSLog(@"timerWithTimeInterval block -- %@",[[NSRunLoop currentRunLoop] currentMode]);
}];
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
底层调用了CFRunLoopAddTimer：
image.png
4.1.1 CFRunLoopAddTimer
//runloop timer mode
void CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef rlt, CFStringRef modeName) {
CHECK_FOR_FORK();
if (__CFRunLoopIsDeallocating(rl)) return;
if (!__CFIsValid(rlt) || (NULL != rlt->_runLoop && rlt->_runLoop != rl)) return;
__CFRunLoopLock(rl);
//kCFRunLoopCommonModes 集合mode
if (modeName == kCFRunLoopCommonModes) {
CFSetRef set = rl->_commonModes ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModes) : NULL;
if (NULL == rl->_commonModeItems) {
rl->_commonModeItems = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
}
//将 timer 加入 modeItems 中。
CFSetAddValue(rl->_commonModeItems, rlt);
if (NULL != set) {
CFTypeRef context[2] = {rl, rlt};
/* add new item to all common-modes */
//加入所有的command modes 中。
CFSetApplyFunction(set, (__CFRunLoopAddItemToCommonModes), (void *)context);
CFRelease(set);
}
} else {//非common mode
//从 runloop 中找到对应的 mode
CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, true);
if (NULL != rlm) {//mode存在
if (NULL == rlm->_timers) {//不存在timer
CFArrayCallBacks cb = kCFTypeArrayCallBacks;
cb.equal = NULL;
//创建timer
rlm->_timers = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &cb);
}
}
if (NULL != rlm && !CFSetContainsValue(rlt->_rlModes, rlm->_name)) {
__CFRunLoopTimerLock(rlt);
//timer没有runloop
if (NULL == rlt->_runLoop) {
//设置runloop
rlt->_runLoop = rl;
} else if (rl != rlt->_runLoop) {//timer所有的runloop与当前runloop不同直接返回。
__CFRunLoopTimerUnlock(rlt);
__CFRunLoopModeUnlock(rlm);
__CFRunLoopUnlock(rl);
return;
}
//将timer 加入 mode中。
CFSetAddValue(rlt->_rlModes, rlm->_name);
__CFRunLoopTimerUnlock(rlt);
__CFRunLoopTimerFireTSRLock();
__CFRepositionTimerInMode(rlm, rlt, false);
__CFRunLoopTimerFireTSRUnlock();
if (!_CFExecutableLinkedOnOrAfter(CFSystemVersionLion)) {
// Normally we don't do this on behalf of clients, but for
// backwards compatibility due to the change in timer handling...
//唤醒runloop
if (rl != CFRunLoopGetCurrent()) CFRunLoopWakeUp(rl);
}
}
if (NULL != rlm) {
__CFRunLoopModeUnlock(rlm);
}
}
__CFRunLoopUnlock(rl);
}
根据要加入的mode区分是common mode和非common mode将timer加入mode中。这个时候只是将timer加入了mode中，要执行肯定要调用CFRunLoopRun，最终要调用CFRunLoopRunSpecific。
4.1.2 CFRunLoopRunSpecific
CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
//对应声明
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled)
CFRunLoopGetCurrent()创建runloop。mode默认给的是kCFRunLoopDefaultMode。1.0e10（1 * 1010）表示超时时间。returnAfterSourceHandled表示source处理后是否返回。
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) { /* DOES CALLOUT */
CHECK_FOR_FORK();
if (__CFRunLoopIsDeallocating(rl)) return kCFRunLoopRunFinished;
__CFRunLoopLock(rl);
//根据 modeName 找到本次运行的 mode
CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
//如果没找到 || mode中没有注册任何事件，则就此停止，不进入循环
if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
Boolean did = false;
if (currentMode) __CFRunLoopModeUnlock(currentMode);
__CFRunLoopUnlock(rl);
return did ? kCFRunLoopRunHandledSource : kCFRunLoopRunFinished;
}
volatile _per_run_data *previousPerRun = __CFRunLoopPushPerRunData(rl);
//取上一次运行的 mode
CFRunLoopModeRef previousMode = rl->_currentMode;
//如果本次mode和上次的mode一致
rl->_currentMode = currentMode;
//初始化一个result为kCFRunLoopRunFinished
int32_t result = kCFRunLoopRunFinished;
if (currentMode->_observerMask & kCFRunLoopEntry )
// 1. 通知 Observers: RunLoop 即将进入 loop。
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
//run
result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
if (currentMode->_observerMask & kCFRunLoopExit )
// 10. 通知 Observers: RunLoop 即将退出。
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
__CFRunLoopModeUnlock(currentMode);
__CFRunLoopPopPerRunData(rl, previousPerRun);
rl->_currentMode = previousMode;
__CFRunLoopUnlock(rl);
return result;
}
- 根据
modeName找到本次运行的mode。 - 1.通知
ObserversRunLoop即将进入loop。 - 调用
__CFRunLoopRun运行循环。 - 10.通知
ObserversRunLoop即将退出。
4.1.3 __CFRunLoopRun
在__CFRunLoopRun中调用了__CFRunLoopDoTimers：
// rl and rlm are locked on entry and exit
static Boolean __CFRunLoopDoTimers(CFRunLoopRef rl, CFRunLoopModeRef rlm, uint64_t limitTSR) { /* DOES CALLOUT */
Boolean timerHandled = false;
CFMutableArrayRef timers = NULL;
//从mode中获取timers进行处理
for (CFIndex idx = 0, cnt = rlm->_timers ? CFArrayGetCount(rlm->_timers) : 0; idx < cnt; idx++) {
CFRunLoopTimerRef rlt = (CFRunLoopTimerRef)CFArrayGetValueAtIndex(rlm->_timers, idx);
if (__CFIsValid(rlt) && !__CFRunLoopTimerIsFiring(rlt)) {
if (rlt->_fireTSR <= limitTSR) {
if (!timers) timers = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(timers, rlt);
}
}
}
for (CFIndex idx = 0, cnt = timers ? CFArrayGetCount(timers) : 0; idx < cnt; idx++) {
CFRunLoopTimerRef rlt = (CFRunLoopTimerRef)CFArrayGetValueAtIndex(timers, idx);
//执行timer
Boolean did = __CFRunLoopDoTimer(rl, rlm, rlt);
timerHandled = timerHandled || did;
}
if (timers) CFRelease(timers);
return timerHandled;
}
找到mode中的所有timer然后调用__CFRunLoopDoTimer。
4.1.4 __CFRunLoopDoTimer
image.png
在__CFRunLoopDoTimer中进行了时间的判断以及timer回调的调用并且重新计算了_fireTSR。这样整个调用流程就与回调堆栈吻合了。
CFRunLoopAddTimer -> CFRunLoopRunSpecific -> __CFRunLoopRun -> __CFRunLoopDoTimers -> __CFRunLoopDoTimer -> __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__。
4.2 source 事务处理
与timer相同source会调用CFRunLoopAddSource：
image.png
将source加入mode中。同样调用是在__CFRunLoopRun中。
4.2.1 __CFRunLoopDoSources0
image.png
在__CFRunLoopDoSources0中调用了__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__。
4.2.2 __CFRunLoopDoSources1
image.png
__CFRunLoopDoSources1最终调用了__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__
CFRunLoopAddSource -> CFRunLoopRunSpecific -> __CFRunLoopRun -> __CFRunLoopDoSources0/__CFRunLoopDoSources1 -> __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__ /__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__
4.3 observer 事务处理
同理observer会调用CFRunLoopAddObserver。
4.3.1 CFRunLoopAddObserver
image.png
将observer加入_observers或者_commonModeItems中。同样调用是在__CFRunLoopRun中。
4.3.2 __CFRunLoopDoObservers
image.png
__CFRunLoopDoObservers最终调用__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__传递了状态参数。
CFRunLoopAddObserver -> CFRunLoopRunSpecific -> __CFRunLoopRun -> __CFRunLoopDoObservers(状态参数) -> __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(状态参数)
4.4 回调函数
4.4.1 CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(CFRunLoopTimerCallBack func, CFRunLoopTimerRef timer, void *info) {
if (func) {
func(timer, info);
}
asm __volatile__(""); // thwart tail-call optimization
}
timer直接调用回调函数，传递timer参数。
4.4.2 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__(void (*perform)(void *), void *info) {
if (perform) {
perform(info);
}
asm __volatile__(""); // thwart tail-call optimization
}
source0直接调用perform。
4.4.3 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__(
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
void *(*perform)(void *msg, CFIndex size, CFAllocatorRef allocator, void *info),
mach_msg_header_t *msg, CFIndex size, mach_msg_header_t **reply,
#else
void (*perform)(void *),
#endif
void *info) {
if (perform) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
*reply = perform(msg, size, kCFAllocatorSystemDefault, info);
#else
perform(info);
#endif
}
asm __volatile__(""); // thwart tail-call optimization
}
source1不同架构处理不同，iOS上与source0处理相同。
4.4.4 CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION
static void __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(CFRunLoopObserverCallBack func, CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) {
if (func) {
func(observer, activity, info);
}
asm __volatile__(""); // thwart tail-call optimization
}
observer调用回调函数其中传递了activity状态参数。
4.4.5 CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE
static void __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__() __attribute__((noinline));
static void __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(void *msg) {
_dispatch_main_queue_callback_4CF(msg);
asm __volatile__(""); // thwart tail-call optimization
}
直接调用_dispatch_main_queue_callback_4CF。
4.5.6 source1 与 source0
点击触摸事件会先调用source1：
image.png
然后交给source0处理：
image.png
之后才会进入触摸回调。
系统先通过source1唤醒runloop然后交给source0处理事件。
五、runloop 原理
在CFRunLoopRun的过程中do...while的条件是根据返回的状态判断的：
enum {
kCFRunLoopRunFinished = 1,//完成
kCFRunLoopRunStopped = 2,//结束
kCFRunLoopRunTimedOut = 3,//超时
kCFRunLoopRunHandledSource = 4//处理完source
};
在CFRunLoopRunSpecific的过程中也有状态的切换：
/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
kCFRunLoopEntry = (1UL << 0),//启动
kCFRunLoopBeforeTimers = (1UL << 1),//将要处理 timer 事件
kCFRunLoopBeforeSources = (1UL << 2),//将要处理 Source 事件
kCFRunLoopBeforeWaiting = (1UL << 5),//将要进入休眠状态,即将由用户态切换到内核态
kCFRunLoopAfterWaiting = (1UL << 6),//被唤醒，即从内核态切换到用户态后
kCFRunLoopExit = (1UL << 7),//退出
kCFRunLoopAllActivities = 0x0FFFFFFFU //监听所有状态
};
可以通过CFRunLoopActivity监听整个runloop的生命周期。
runloop的整个核心逻辑就在__CFRunLoopRun中：
image.png
整个流程伪代码如下：
//获取 mode 处理
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {
/// 首先根据modeName找到对应mode
CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
/// 1.通知 Observers: RunLoop 即将进入 loop。
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
/// 内部函数，进入loop
result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
/// 10.通知 Observers: RunLoop 即将退出。
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
return result;
}
//核心函数
/**
* 运行run loop
*
* @param rl 运行的RunLoop对象
* @param rlm 运行的mode
* @param seconds run loop超时时间
* @param stopAfterHandle true:run loop处理完事件就退出 false:一直运行直到超时或者被手动终止
* @param previousMode 上一次运行的mode
*
* @return 返回4种状态
*/
static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {
//一些超时逻辑相关的处理
int32_t retVal = 0;
do { //itmes do
/// 2. 通知 Observers: 即将处理timer事件
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
/// 3.通知 Observers: 即将处理Source0（非port）事件
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources)
/// 执行被加入的 block
__CFRunLoopDoBlocks(rl, rlm);
/// 4.处理sources0 (非port)事件
Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
/// 处理sources0返回为YES
if (sourceHandledThisLoop) {
/// 执行被加入的block
__CFRunLoopDoBlocks(rl, rlm);
}
/// 5.如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息（9）。
if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
/// 处理消息
goto handle_msg;
}
/// 6.通知 Observers: RunLoop 的线程即将进入休眠(sleep)。
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
// 设置RunLoop为休眠状态。
__CFRunLoopSetSleeping(rl);
// 内循环，用于接收等待端口的消息
// 进入此循环后，线程进入休眠，直到收到新消息才跳出该循环，继续执行run loop
do {
/// 7.等待被唤醒, 调用 mach_msg 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。
/// 7.1 一个基于 port 的 Source1 的事件。
/// 7.2 一个 Timer 到时间了
/// 7.3 RunLoop 自身的超时时间到了
/// 7.4 被其他什么调用者手动唤醒
// mach 事务 - 指令
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
} while(1)
// 取消runloop的休眠状态，也就是唤醒。
__CFRunLoopUnsetSleeping(rl);
/// 8.通知 Observers: RunLoop 的线程刚刚被唤醒了。
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
/// 9.处理唤醒时收到的消息，之后跳转 步骤2
handle_msg:
//9.1 如果一个 Timer 到时间了，触发这个Timer的回调。
if (被Timer唤醒) {
//处理Timers
__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())；
} else if (被GCD唤醒) {
//9.2 如果有dispatch到main_queue的block，执行block
__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
} else if (被Source1唤醒) {
//9.3 如果一个 Source1 (基于port) 发出事件了，处理这个事件。（被source1唤醒）
__CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply)
}
/// 执行加入到Loop的block
__CFRunLoopDoBlocks(rl, rlm);
if (sourceHandledThisLoop && stopAfterHandle) {
//进入loop时参数说处理完事件就返回。
retVal = kCFRunLoopRunHandledSource;
} else if (timeout_context->termTSR < mach_absolute_time()) {
//超出传入参数标记的超时时间了
retVal = kCFRunLoopRunTimedOut;
} else if (__CFRunLoopIsStopped(rl)) {
//被外部调用者强制停止了
__CFRunLoopUnsetStopped(rl);
retVal = kCFRunLoopRunStopped;
} else if (rlm->_stopped) {
//自动停止了
rlm->_stopped = false;
retVal = kCFRunLoopRunStopped;
} else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
//source/timer/observer一个都没有了
retVal = kCFRunLoopRunFinished;
}
} while (0 == retVal);
return retVal;
}
根据源码有以下流程图：
runloop循环流程
同时官方文档中也给出了流程总结：
image.png
5.1 runloop 休眠与唤醒
在第7步前后分别调用了__CFRunLoopSetSleeping与__CFRunLoopUnsetSleeping进行休眠与唤醒操作：
image.png
这里是通过Darwin中的Mach来进行内核态和用户态的切换：
image.png
通过mach_msg()函数接收、发送消息，本质上是调用mach_msg_trap()。在用户态调用 mach_msg_trap()时会切换到内核态，内核态中内核实现的mach_msg()函数会完成实际的工作。
比如触摸屏幕摸到硬件(屏幕)将事件先包装成Event告诉source1(port)，source1唤醒RunLoop然后将事件Event分发给source0由source0来处理。
5.2 mode 切换
默认情况下runloop运行后是在kCFRunLoopDefaultMode模式下的，那么runloop是如何切换mode的呢？
既然要切换mode那么肯定要改变CFRunLoopRunSpecific的参数，搜索CFRunLoopRunSpecific后有在CFRunLoopRunInMode中有调用：
SInt32 CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) { /* DOES CALLOUT */
CHECK_FOR_FORK();
return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}
而CFRunLoopRunInMode并没有找到调用的时机，给CFRunLoopRunInMode下符号断点：
image.png
image.png
可以看到是在-[NSRunLoop(NSRunLoop) runMode:beforeDate:]中以及GSEventRunModal中进行切换的。
六、runloop 应用场景
6.1 runloop 与 mode
6.1.1 mode 与 timer
常用的一个场景是在TableView中的定时器在滚动的时候回调是不执行的。因为这个时候runloop的mode从NSDefaultRunLoopMode切换到了UITrackingRunLoopMode。而timer默认情况下是加在NSDefaultRunLoopMode下的。
这个时候就需要将timer同时加到NSDefaultRunLoopMode与UITrackingRunLoopMode下：
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
加入NSRunLoopCommonModes下就可以了。当然也可以使用GCD的timer实现计时器。
6.1.2 mode 与 页面刷新
怎样保证子线程数据回来更新UI的时候不打断用户的滑动操作？
不打断用户操作那么当runloop在NSDefaultRunLoopMode模式的时候页面就不在滑动状态。那么就当主线程RunLoop由UITrackingRunLoopMode切换到NSDefaultRunLoopMode时再去更新UI：
[self performSelectorOnMainThread:@selector(reloadData) withObject:nil waitUntilDone:NO modes:@[NSDefaultRunLoopMode]];
6.2 runloop 与 线程
RunLoop与线程时是一一对应的，数据以key(线程)-value(runloop)存储在全局的字典中。默认情况下线程时不开启runloop的（主线程除外）。
6.2.1 线程 与 timer
有如下案例（在主线程调用）：
- (void)testRunloop {
NSLog(@"1");
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"2");
[self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:10];
NSLog(@"3");
});
NSLog(@"4");
}
- (void)performSelectorAction {
NSLog(@"5");
}
输出：
1
4
2
3
由于performSelector带了延迟函数（即使延迟时间为0），内部创建了timer，而子线程没有开启runloop添加timer会失败，该方法也就失效了。
当然如果是主队列则没有问题，同步函数则结果依赖调用同步函数的线程。
修改代码如下：
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"2");
[[NSRunLoop currentRunLoop] run];
[self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:10];
NSLog(@"3");
});
这个时候performSelectorAction仍然不执行，run后runloop中没有事务导致runloop退出了。退出后再添加timer显然不会执行。
那么将run的逻辑在添加timer后就可以了：
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"2");
[self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:10];
[[NSRunLoop currentRunLoop] run];
NSLog(@"3");
});
这个时候输出：
1
4
2
5
3
这个时候即使delay传0也没问题，进一步说明了NStimer是不准的。
那么有个疑问，既然performSelector: withObject : afterDelay:底层是对timer的封装，那么肯定会调用CFRunLoopAddTimer。而runloop不存在的情况下这个函数会直接返回：
image.png
按照理解应该先创建runloop然后添加timer再启动：
[NSRunLoop currentRunLoop];
[self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:0];
[[NSRunLoop currentRunLoop] run];
为什么先添加timer也没问题呢？
image.png
performSelector: withObject : afterDelay:内部会先创建runloop然后添加timer，我们只需要在添加timer后启动runloop。- 自己启动
RunLoop，一定要在添加item后。
6.2.2 线程常驻
线程保活在实际开发中经常会遇到一些耗时且需要频繁处理的工作，这些工作和UI无关，比如大文件的下载、后台进行数据的上报等。线程常驻的好处是不用频繁的开辟销毁线程节省资源。
6.2.2.1 线程释放验证
创建一个HPThread继承自NSThread，只重写dealloc方便验证线程是否销毁：
- (void)dealloc {
NSLog(@"%s",__func__);
}
调用如下：
HPThread *thread = [[HPThread alloc] initWithTarget:self selector:@selector(threadAction) object:nil];
[thread start];
- (void)threadAction {
@autoreleasepool {
for (int i = 0; i < 100; i++) {
NSLog(@"子线程任务 %d - %@",i,[NSThread currentThread]);
}
NSLog(@"子线程任务结束- %@",[NSThread currentThread]);
}
}
这个时候在threadAction中任务执行完毕后HPThread就释放了：
image.png
这个时候如果HPThread改为属性被持有：
@property (nonatomic, strong) HPThread *thread;
HPThread的dealloc就不会执行了，那么这个时候线程释放了么？
创建一个新任务在self. thread中执行：
UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(tapAction:)];
[self.view addGestureRecognizer:tap];
- (void)tapAction:(UITapGestureRecognizer *)tap {
//waitUntilDone:YES 执行完 otherChildThreadAction 才执行后续的逻辑，为 NO 就一起直接执行了。
[self performSelector:@selector(otherChildThreadAction) onThread:self.thread withObject:nil waitUntilDone:NO];
NSLog(@"单点事件执行完毕");
}
- (void)otherChildThreadAction {
@autoreleasepool {
for (int i = 0; i < 10; i++) {
NSLog(@"otherChildThreadAction 子线程任务 %d - %@",i,[NSThread currentThread]);
}
NSLog(@"otherChildThreadAction 子线程任务结束- %@",[NSThread currentThread]);
}
}
这个时候otherChildThreadAction并没有执行：
image.png
说明HPThread创建的线程已经释放了。那么说明仅仅持有HPThread并不能保证线程存活。
6.2.2.2 线程保活
image.png
显然pthread_create创建的线程在任务执行完毕后就被释放了，要确保线程执行完后不被释放，那么就要持有它。那么就有两种方式：
- 1.使用
pthread代替HPThread实现线程创建逻辑。 - 2.使用
runloop持有thread。为了让thread不释放，runloop要一直有事务。
使用 pthread 比较麻烦更好的方案是使用runloop的方案。
修改threadAction如下：
- (void)threadAction {
@autoreleasepool {
for (int i = 0; i < 100; i++) {
NSLog(@"子线程任务 %d - %@",i,[NSThread currentThread]);
}
// RunLoop 任务执行完毕后线程就销毁了，线程保活需要加入 runloop
NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
//为了 runloop 不退出
[runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
[runLoop run];
//end 不会执行，因为跑do...while 循环了。
NSLog(@"子线程任务结束- %@",[NSThread currentThread]);
}
}
这样就保证了线程不被释放：
image.png
但是这个时候又存在一个问题了。self -> thread -> self造成了循环引用。需要在结束任务的时候退出线程打破循环引用：
@property (nonatomic, assign) BOOL stopped;
UITapGestureRecognizer *doubleTap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(doubleTapAction:)];
doubleTap.numberOfTapsRequired = 2;
[self.view addGestureRecognizer:doubleTap];
- (void)doubleTapAction:(UITapGestureRecognizer *)tap {
[self performSelector:@selector(exitThread) onThread:self.thread withObject:nil waitUntilDone:NO];
NSLog(@"双击事件执行完毕");
}
- (void)exitThread {
self.stopped = YES;
//停止RunLoop，这样只会停止当次的。
CFRunLoopStop(CFRunLoopGetCurrent());
[self.thread cancel];
//打破循环引用
self.thread = nil;
NSLog(@"%s %@", __func__, [NSThread currentThread]);
}
thread也可以使用- (instancetype)initWithBlock:(void (^)(void))block来创建。虽然没有循环引用了，vc也能释放，但是runloop持有了thread导致线程和runloop不能释放。
这个时候双击然后返回页面仍然不能释放VC，由于runloop是通过run开启的（runUntilDate）也一样，run一旦成功会不停的调用runMode:beforeDate:来运行runloop，而于CFRunLoopStop只停止了一次runloop（runloop仍然持有了线程）。修改threadAction如下：
- (void)threadAction {
@autoreleasepool {
for (int i = 0; i < 100; i++) {
NSLog(@"子线程任务 %d - %@",i,[NSThread currentThread]);
}
// RunLoop 任务执行完毕后线程就销毁了，线程保活需要加入 runloop
NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
//为了 runloop 不退出
[runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
while (!self.stopped) {
// 这个方法在没有任务时就睡眠 任务完成了就会退出loop
[runLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
}
//不会执行，因为跑do...while 循环了。 self.stopped
NSLog(@"子线程任务结束- %@",[NSThread currentThread]);
}
}
这个时候通过self.stopped变量控制是否继续run就解决问题了。
runMode: beforeDate:只控制执行一次：
image.png
但是当我们将runMode: beforeDate:的mode修改为NSRunLoopCommonModes后：
image.png
给thread添加任务也不执行，并且cup占满。
等价于UITrackingRunLoopMode：
image.png
所以在while循环中不能一直run在UITrackingRunLoopMode模式。
当然也可以使用CFRunLoop相关函数实现：
// 创建上下文
CFRunLoopSourceContext context = {0};
// 创建source
CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
// Runloop中添加source
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
// 销毁source
CFRelease(source);
// 启动
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e10, false);
那么CFRunLoop尝试使用common modes：
image.png
直接报错CFRunLoopRunSpecific模式只能传递特定模式。这也就是runMode: beforeDate:启动后给thread添加任务也不执行的原因。
CFRunLoopRunInMode与runMode: beforeDate:只能运行在特定的模式下。CFRunLoopStop只能退出单次的runloop。
总结:
runloop是一个事件循环，分为内核态和用户态。底层是对do...while的封装。与do...while的区别是它有休眠和唤醒逻辑，从而节省cpu资源、提高程序的性能。NSRunloop是对CFRunloop的封装。runloop与线程一一对应，开启runloop依赖于线程，线程不一定开启runloop（主线程默认开启，子线程需要手动开启）。底层是存储在可变字典中key为线程，value为runloop。runloop与mode是一对多的关系。kCFRunLoopDefaultMode/NSDefaultRunLoopMode：默认模式。UITrackingRunLoopMode：跟踪用户交互事件。kCFRunLoopCommonModes/NSRunLoopCommonModes：伪模式，不是一种真正的运行模式，本质上是同步Source/Timer/Observer到多个Mode中。
mode与source、timer、observer也是一对多的关系。CFRunLoopSource分为source0与source1。source0：基于非port也就是用户触发的事件，需要手动唤醒RunLoop，将当前线程从内核态切换到用户态。source1：基于port，包含一个mach_port和一个回调。可监听系统端口和通过内核和其他线程发送的消息，能主动唤醒RunLoop，接收分发系统事件。具备唤醒线程的能力。
CFRunLoopTimer基于时间的触发器，在预设的时间点唤醒RunLoop执行回调。基于runloop所以不是实时的（RunLoop只负责分发消息，如果线程当前正在处理繁重的任务，有可能导致Timer本次延时或者少执行一次）。CFRunLoopObserver可以监听runloop的状态。
1528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
