RunLoop应用
image.png
这张图是苹果官网中图，接下来通过示例理解这种图
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
// 循环引用
[NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
// __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
NSLog(@"1111");
}];
//
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(gotNotification:) name:@"MyNotification" object:nil];
[self performSelector:@selector(fire) withObject:nil afterDelay:1.0];
////
dispatch_async(dispatch_get_main_queue(), ^{
//__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
NSLog(@"hello word");
});
//
void (^block)(void) = ^{
//__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__
NSLog(@"123");
};
block();
}
- (void)fire {
//__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
NSLog(@"performSeletor");
}
- (void)gotNotification:(NSNotification *)noti {
NSLog(@"gotNotification = %@",noti);
}
#pragma mark - 触摸事件
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
NSLog(@"来了,老弟!!!");
// __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__
[[NSNotificationCenter defaultCenter] postNotificationName:@"MyNotification" object:@"ssl"];
}
@end
首先测试下NStimer，断点bt下
image.png
- 这里timer收到runloop影响
- 这里有个
__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
测试下block
image.png
- 这里block收到runloop影响
- 这里有个
__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__
这里就不一一进行测试了，给出其余几种情况
- timer：
__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__ - GCD主队列：
__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__ - source0:
__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__ - source1:
__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__ - observer ：
__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__ - block:
__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__
RunLoop作用
- 保持程序的持续运行
- 处理App的各种时间（触摸、定时器等）
- 节省
CPU资源、提供程序的性能：做事的时候做事、休息的时候休息
RunLoop与线程关系
在CFRunLoop源码中找到CFRunLoopGetMain和CFRunLoopGetCurrent方法
image.png
进入_CFRunLoopGet0方法
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
if (pthread_equal(t, kNilPthreadT)) {
t = pthread_main_thread_np();
}
__CFLock(&loopsLock);
if (!__CFRunLoops) {
__CFUnlock(&loopsLock);
// 创建一个可变字典
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
// 创建主线程runloop
CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
// 进行绑定 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);
}
// 根据当前线程获取loop
CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
__CFUnlock(&loopsLock);
// 如果不是主线程，进行类似操作将线程和创建的CFRunLoopRef进行绑定
if (!loop) {
CFRunLoopRef newLoop = __CFRunLoopCreate(t);
__CFLock(&loopsLock);
loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
if (!loop) {
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;
}
- 如果
__CFRunLoops不存在，创建CFMutableDistionaryRef,并默认初始化主线程的RunLoop并将RunLoop放入到字典中,线程为key，runloop为value - 在通过线程获取
RunLoop时，以key-value方式从字典中获取对应的RunLoop； - 如果
RunLoop为空,则创建一个newLoop，以线程为key，RunLoop为value，存储到__CFRunLoops中
【线程总结】线程的RunLoop会默认被创建，而子线程的RunLoop是懒加载的，需要时才会创建，RunLoop和线程是一对一的关系，存储在一个字典中。
- 子线程
runLoop分析
dispatch_queue_t queue = dispatch_queue_create("", NULL);
dispatch_async(queue, ^{
NSLog(@"running....");
[NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
NSLog(@"helloc timer...%@", [NSThread currentThread]);
}];
});
image.png
由上图可知，这里只打印了
定时器前的打印，定时任务并没有执行，这是因为NSTimer需要依赖于RunLoop，主线程的RunLoop默认开启，而子线程的RunLoop是懒加载，需要手动开启。
image.png
RunLoop数据结构
创建RunLoop是使用的__CFRunLoopCreate函数，查看函数实现：
image.png
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;
CFRunLoopModeRef _currentMode;
CFMutableSetRef _modes;
struct _block_item *_blocks_head;
struct _block_item *_blocks_tail;
CFAbsoluteTime _runTime;
CFAbsoluteTime _sleepTime;
CFTypeRef _counterpart;
};
由这个结构体，可以得知一个runLoop对应_commonModes,这个_commonModes是个集合类型，所以一个runLoop对应多个mode
mode定义
struct __CFRunLoopMode {
CFStringRef _name;
CFMutableSetRef _sources0;
CFMutableSetRef _sources1;
CFMutableArrayRef _observers;
CFMutableArrayRef _timers;
...
};
- CFRunLoopModeRef代表RunLoop的运行模式；
- 一个RunLoop包含若干个 Mode，每个 Mode 又包含若干个Source0/Source1/Timer/Observer；
- RunLoop启动时只能选择其中一个 Mode，作为 currentMode；
如果需要切换 Mode，只能退出当前 Loop，再重新选择一个 Mode 进入，切换模式不会导致程序退出； - 不同 Mode 中的
Source0/Source1/Timer/Observer能分隔开来，互不影响； - 如果 Mode 里没有任何
Source0/Source1/Timer/Observer，RunLoop会立马退出。
__CFRunLoopMode源码定义中包括了4个set集合_sources0、_sources1、_observers、_timers，这四个集合也就是我们常说的事件（事务）。所以我们可以得出结论：CFRunLoopMode和sourses、timer、observer也是一对多的关系。
这里的timer、observer比较好理解，什么是_sources0、_sources1呢？
image.png
mode类型
-kCFRunLoopDefaultMode 默认的运行模式，通常主线程是在这个Mode下运行
-UITrackingRunLoopMode 界面跟踪Mode，用于ScrollView等视图，追踪触摸滑动，保证界面的滑动不受其他Mode的影响
-UIInitializationRunLoopMode 在刚启动App时进入的第一个Mode，启动完成后就不在使用
-GSEventReceiveRunLoopMode 接受系统时间的内部Mode，通常用不到
-kCFRunLoopCommonModes 是一个伪模式，可以在标记为CommonModes的模式下运行，RunLoop会自动将_commonModeItems里的source、observe、timer同步到具有标记的Mode里。
image.png
runLoop原理
在源码中查找CFRunLoopRunSpecific的方法实现，见下图：
image.png
由上图可知：这个函数是对runLoop的生命周期的处理,进入
__CFRunLoopRun
/**
* 运行 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: RunLoop 即将触发 Timer 回调。
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
/// 3. 通知 Observers: RunLoop 即将触发 Source0 (非port) 回调。
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources)
/// 执行被加入的block
__CFRunLoopDoBlocks(rl, rlm);
/// 4. RunLoop 触发 Source0 (非port) 回调。
Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
/// 处理sources0返回为YES
if (sourceHandledThisLoop) {
/// 执行被加入的block
__CFRunLoopDoBlocks(rl, rlm);
}
/// 5. 如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息。
if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
/// 如果接收到了消息的话，前往第9步开始处理消息
goto handle_msg;
}
/// 6.通知 Observers: RunLoop 的线程即将进入休眠(sleep)。
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
__CFRunLoopSetSleeping(rl);
/// 7. 接收waitSet端口的消息
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
/// 7. 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。
/// • 一个基于 port 的Source 的事件。
/// • 一个 Timer 到时间了
/// • RunLoop 自身的超时时间到了
/// • 被其他什么调用者手动唤醒
// 取消runloop的休眠状态
__CFRunLoopUnsetSleeping(rl);
/// 8. 通知 Observers: RunLoop 的线程刚刚被唤醒了。
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
handle_msg:
if (被Timer唤醒) {
/// 9.1 如果一个 Timer 到时间了，触发这个Timer的回调。
__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) 发出事件了，处理这个事件
__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;
}
/// 如果没超时，mode里没空，loop也没被停止，那继续loop。
} while (0 == retVal);
return retVal;
}
下图就是上图的处理逻辑
image.png
【总结】
RunLoop是通过系统内部维护的循环进行事件、消息管理的一个对象。RunLoop实际上就是一个do...while循环，有任务时开始，无任务时休眠。本质是通过mach_msg()函数接收、发送消息。
CFRunLoopModeRef 这样设计有什么好处？Runloop为什么会有多个 Mode？
-Mode 做到了屏蔽的效果，当RunLoop运行在 Mode1 下面的时候，是处理不了 Mode2 的事件的；
比如NSDefaultRunLoopMode默认模式和UITrackingRunLoopMode滚动模式，滚动屏幕的时候就会切换到滚动模式，就不用去处理默认模式下的事件了，保证了 UITableView等的滚动顺畅。
RunLoop与线程的关系：
- 每个线程都有一个与之对应的RunLoop，所以RunLoop与线程是一一对应的，其绑定关系通过一个全局的DIctionary存储，线程为key，runloop为value。
- 线程中的RunLoop主要是用来管理线程的，当线程的RunLoop开启后，会在执行完任务后进行休眠状态，当有事件触发唤醒时，又开始工作，即有活时干活，没活就休息
- 主线程的RunLoop是默认开启的，在程序启动之后，会一直运行，不会退出
- 其他线程的RunLoop默认是不开启的，如果需要，则手动开启
RunLoop中涉及到5个重要的类：
CFRunLoop - RunLoop对象
CFRunLoopMode - 五种运行模式
CFRunLoopSource - 输入源/事件源，包括Source0和Source1
CFRunLoopTimer - 定时源，也就是NSTimer
CFRunLoopObserve - 观察者，用来监听RunLoop
CFRunLoopSource - 事件源
- Source1:基于mach_port和回调函数指针，也就是端口通讯，处理来自系统内核或其他进程的事件，比如点击手机屏幕
- Source0:非基于Port的处理事件，也就是应用层事件（内部事件、APP负责管理的事件，UIEvent），包含一个回调函数指针，需要手动标记为待处理或者手动唤醒RunLoop，如performSelector、block等
例如：一个APP在前台静止，用户点击APP界面，屏幕表面的时事件会先包装成Event告诉source1（基于mach_port），source1唤醒RunLoop将事件Event分发给source0，由source0来处理。
CFRunLooTimer - 定时源
就是NSTimer，在预设的时间点唤醒RunLoop执行回调。因为它是基于RunLoop的，因此它不是实时的（Timer是不准确的，因为RunLoop只负责分发源消息。如果线程当前正在处理繁重的任务，就有可能导致Timer本次延时，或者少执行一次）。
CFRunLoopObserver - 观察者
用来监听时间点事件CFRunLoopActivity。
- KCFRunLoopEntery RunLoop准备启动
- kCFRunLoopBeforeTimers RunLoop将要处理一些Timer相关的事件
- kCFRunLoopBeforeSources RunLoop将要处理一些Source事件
- kCFRunLoopBeforeWaiting RunLoop将要进行休眠状态，即将由用户状态切换内核态
- kCFRunLoopAfterWaiting RunLoop被唤醒，即从内核态切换到用户态
- kCFRunLoopExit RunLoop退出
- kCfRunLoopAllActivitires 监听所有状态
为什么main函数能够保持一直存在且不退出？
在main函数内容会调用UIApplication函数，而在UIAPPlicationMain内部会启动主线程的RunLoop，可以做到有消息处理，能够迅速从内核态到用户态的切换，立刻唤醒处理，而没有消息处理时，通过用户态到内核态的切换进入等待状态，避免资源的占用。因此main函数能够一直存在并且不退出。
NSRunLoop 和 CFRunLoopRef 区别
- NSRunLoop是基于CFRunLoopRef面向对象的API，是不安全的
- CFRunLoopRef是基于C语言，是线程安全的
Runloop的mode作用是什么？
mode主要是用于指定RunLoop中事件优先级的
