iOS RunLoop

简介

 

我们的应用可以在无人操作的时候休息，有事件的时候又立刻响应，因为有runloop的存在。

runloop代表正在运行的循环，runloop是为线程而生，每个线程都有与之对应的runloop。

主线程的runloop是默认启动的，由UIApplicationMain函数创建，对于其他线程来说，runloop默认是没有启动的。

 

runloop内部实现

 

runloop和mode的关系

（图出自底下参考博客中，侵删）

一个runloop 有多个mode 一个mode有若干个mode item（source/Timer/observer）

每次调用runloop的主函数时，只能指定其中一个mode，也被成为currentmode。

如果需要切换mode，只能退出loop，再重新指定一个mode进入，这样做是为了分隔开不同组的source/Timer/Observer，使其互不影响。

 

mode Item

CFRunLoopSourceRef    ：事件产生的地方，source有两个版本，source0和source1

CFRunLoopTimeRef       ： 基于时间的触发器

CFRunLoopObserverRef ： 观察者，每个observer都包含了一个回调，当runloop的状态变化的时候，观察者就能通过回调函数接受到这个变化。

一个item可以被加入多个mode，但是一个item被重复加入同一个mode时是不会有效果的，如果一个mode中一个item也没有，则runloop回直接退出，不进入循环。

 

runloop的实现

/// 用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底层实现

 

RunLoop 的核心是基于 mach port 的，其进入休眠时调用的函数是 mach_msg()

RunLoop 的核心就是一个 mach_msg() (第7步)，RunLoop 调用这个函数去接收消息，如果没有别人发送 port 消息过来，内核会将线程置于等待状态。

 Mach 的对象间不能直接调用，只能通过消息传递的方式实现对象间的通信。”消息”是 Mach 中最基础的概念，消息在两个端口 (port) 之间传递，这就是 Mach 的 IPC (进程间通信) 的核心。

 

苹果用 RunLoop 实现的功能

1、AutoreleasePool

     App启动后，苹果在主线程的runloop里面注册了两个observer，其回调都是-warpRunLoopWithAutoreleasePoolHandler（）

     第一个observer监听的事件是Entry （即将进入loop），这时候会调用objc_autoreleasePoolPush()创建自动释放池，优先级最高，保证创建发生在其他回调之前

     第二个observer监听了两个事件：

beforeWaiting（准备进入休眠）时调用objc_autoreleasePoolPop() &objc_autoreleasePoolPush()释放自动释放池和创建新的自动释放池

Exit（即将退出loop）时调用objc_autoreleasePoolPop（）来释放自动释放池（优先级最低，保证释放发生在其他回调之后）

所以看起来在每次runloop迭代的时候都会创建和释放自动释放池，保证一个runloop的过程中的临时变量可以被及时的释放，防止内存泄漏。

所有的autorelease对象，在出了作用域之后，会被自动的加入到最近创建的自动释放池里，在一次完整的运行循环结束之前，会被销毁，在运行循环检测到事件并启动之后，就会创建新的自动释放池。

注意：自定义的NSoperation和NSThread需要手动创建自动释放池，否则出了作用域后，自动释放对象会因为没有自动释放池去处理而造成内存泄漏。

但对于blockOperation和invocation这种默认的operation系统已经帮我们封装好了，不需要手动创建自动释放池。

 

2、事件响应

苹果注册了一个source1（基于mach port）用来接收系统事件，其回调函数为-HOHIDEventSystemClientQueueCallback()

当一个硬件事件（触摸、锁屏、摇晃等）发生后，首先IOKit，frameWork生成一个IOHIDEvent事件并由SpringBpard接收。随后用mach port转发给需要的App进程，然后在runloop中注册的那个source1就会被唤醒触发回调，再调用-UIApplicationHandleEventQueue()进行应用内部的事件分发，然后就是事件的传递流程了。

 

3、界面更新

   当操作UI，比如改变frame，更新UIView/CALayer的层次或者手动调用setNeedLayout/setNeedDsiplay方法后，这个UIView/CALayer就被标记为待处理，并被提交到一个全局的容器中去。

苹果注册了一个observer监听BeforeWaiting（即将进入休眠）和Exit（即将退出runloop）事件，回调去执行一个函数。

这个函数里面会遍历所有待处理的UiView/CALayer，执行实际的绘制和调整，并且更新界面UI。

 

4、定时器

一个NSTimer注册到runloop后，runloop会为其重复的时间点注册好事件。例如 7:00 7:10 7:20这几个时间点。

RunLoop为了节省资源，并不会在非常准确的时间点回调这个Timer。

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

如果某个时间点被错过了，例如执行了一个很长的任务，则那个时间点的回调也会跳过去，不会延后执行。

 

5、PerformSelecter

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

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

 

6、dispatch_async

当调用 dispatch_async(dispatch_get_main_queue(), block) 时，libDispatch 会向主线程的 RunLoop 发送消息，RunLoop会被唤醒，并从消息中取得这个 block，并在回调 __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__() 里执行这个 block。但这个逻辑仅限于 dispatch 到主线程，dispatch 到其他线程仍然是由 libDispatch 处理的。

 

参考博客

https://blog.ibireme.com/2015/05/18/runloop/#base