RunLoop 文章已经很多了，结合各大文章做个总结

什么是 RunLoop

RunLoop 人如其名，run 跑，loop 循环，无限的跑，类似于程序中的无限循环，RunLoop 是与线程相关联的基础架构的一部分。 RunLoop 是一个事件处理循环，用于调度和协调接收到的事件。 RunLoop 的目的是保持你的线程活着，在有消息到来的时候唤醒，没有消息的时候休眠。
类似的机制在其他系统也存在
如在 Windows 中的 Message Loop

while(GetMessage(&Msg, NULL, 0, 0) > 0) 
{ 
    TranslateMessage(&Msg); 
    DispatchMessage(&Msg); 
} 

在安卓中的 MessageQueue 和 Looper

public class Looper {
    public static final void loop() {
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        while (true) {
            Message msg = queue.next(); 
            if (msg != null) {
                if (msg.target == null) {
                    return;
                }
                msg.target.dispatchMessage(msg);
                msg.recycle();
            }
        }
    }
}

为什么需要 RunLoop

一般来说一个线程一次只能执行一个任务，执行完成后线程就会退出。对 APP 来说，这显然是不符合我们的要求的，没有人希望 APP 的应用在启动之后就自动退出的。这时候就需要一个机制让线程能随时处理事件但并不退出，如主线程，在我们启动之后可以一直存在，当交互发生，又可以去处理相关的事件。传统的死循环似乎是可以满足我们的要求，但是死循环会导致 CPU 一直空转大量消耗系统性能，RunLoop 真是为了这种场景情况下而生，在没有收到消息的时候会让线程睡眠以避免资源占用、在有消息到来时立刻被唤醒。

NSRunLoop 和 CFRunLoopRef

NSRunLoop 基于 CFRunLoopRef 封装。
CFRunLoopRef 是在 CoreFoundation 框架内的，它提供了纯 C 函数的 API，所有这些 API 都是线程安全的。
NSRunLoop 提供了面向对象的 API，这些 API 不是线程安全的。

RunLoop 执行的流程

这边用 ibireme 博客的图片和代码来说明 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 之 mode

熟悉 NSTimer 的同学一定知道当使用 scheduledTimerWithTimeInterval 系列 API 的时候在 UIScrollView 以及其子类滚动的时候是不会调用回调，如果我们需要要在滚动过程中也可以调用回调回调那就应该这么写

NSTimer *timer = [NSTimer timerWithTimeInterval:1 target:self selector:@selector(repeat:) userInfo:nil repeats:true];
[[NSRunLoop currentRunLoop] addTimer:timer forMode: NSRunLoopCommonModes];

为什么这边涉及到了 RunLoop ？这里的 NSRunLoopCommonModes 又是什么玩意？

这是于 RunLoop 运行的机制有关，一个 RunLoop 的结构大概如下

struct __CFRunLoop {
    CFMutableSetRef _commonModes;     // Set
    CFMutableSetRef _commonModeItems; // Set<Source/Observer/Timer>
    CFRunLoopModeRef _currentMode;    // Current Runloop Mode
    CFMutableSetRef _modes;           // Set
    ...
};

可以看出，在 RunLoop 执行的时候总是会处在某一个 mode 状态下。如刚进入 APP 的时候啥事都没干，这个时候 RunLoop 运行的 mode 是 NSDefaultRunLoopMode（kCFRunLoopDefaultMode），如果页面有个 tableView 你滑动之后这个时候 RunLoop 会切换到 UITrackingRunLoopMode 模式下。NSTimer 的 scheduledTimerWithTimeInterval 系列的 API 默认是将 timer 添加到 NSDefaultRunLoopMode 下的，所以，当你滑动 ScrollView 的时候切换了 mode ，当然不能正常会调你的方法了。

RunLoop mode 的种类

RunLoop 系统预置的 mode 大概有几个常用的

• NSDefaultRunLoopMode(kCFRunLoopDefaultMode)：默认模式。
• UITrackingRunLoopMode：滑动模式，在滑动 ScrollView 的时候会在此模式。
• NSRunLoopCommonModes：通用模式，在滑动 ScrollView 和默认状态都会响应事件。

CommonModes

一个 Mode 可以将自己设置为"CommonMode"（通过将其 ModeName 添加到 RunLoop 的 "commonModes" 中）。每当 RunLoop 的内容发生变化时，RunLoop 都会将事件同步到 CommonMode 的 mode item，什么是 mode item 后文会讲到。这也解释了为什么 timer 加入到 NSRunLoopCommonModes 中会被正确的回调。

管理mode

在 NSRunLoop 这个层面不提供操作 mode 的 API ，在 CFRunLoopRef 提供相关的管理 API,不过只提供了增加 mode 的方法,不提供删除的方法。

// 添加一个  CommonMode
CFRunLoopAddCommonMode(CFRunLoopRef runloop, CFStringRef modeName);
//是否在 某个 mode 下
CFRunLoopRunInMode(CFStringRef modeName, ...);

RunLoop 之 mode item

上文的 RunLoop 流程图中我们可以看到 Source0， Source1，Timer，Observer ，这些都是 mode item。
上一小节，介绍了 RunLoop mode，我们可以看看 mode 的结构

struct __CFRunLoopMode {
    CFStringRef _name;            // Mode Name, 例如 @"kCFRunLoopDefaultMode"
    CFMutableSetRef _sources0;    // Set
    CFMutableSetRef _sources1;    // Set
    CFMutableArrayRef _observers; // Array
    CFMutableArrayRef _timers;    // Array
    ...
};

结合图片理解

可以看出，一个 mode 由 _sources0，_sources1，_observers，_timers构成。在也是每个 RunLoop 周期醒来之后要干的活。

• Source0 只包含了一个回调（函数指针），它并不能主动触发事件。使用时，你需要先调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理，然后手动调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件。

• Source1 包含了一个 mach_port 和一个回调（函数指针），被用于通过内核和其他线程相互发送消息。这种 Source 能主动唤醒 RunLoop 的线程。

• timer 是基于时间的触发器，它和 NSTimer 是toll-free bridged 的，可以混用。其包含一个时间长度和一个回调（函数指针）。当其加入到 RunLoop 时，RunLoop会注册对应的时间点，当时间点到时，RunLoop会被唤醒以执行那个回调。

• 是观察者，每个 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
};

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

更详细的内容可以查看博客：http://blog.ibireme.com/2015/05/18/runloop/

RunLoop 启动和退出

启动

这边以 NSRunLoop 为例，CFRunLoopRef 类似，
启动有3个方法

• run
• runUntilDate:
• runMode:beforeDate:

run 底层是不断（循环）调用runMode:beforeDate:来达到运行目的。
runUntilDate:底层也是调用runMode:beforeDate:来运行，和run不同的是，在指定的时间也就是 UntilDate 参数后会停止调用。

退出

在系统提供的停止 RunLoop 方法只有 CFRunLoopStop()，CFRunLoopStop() 方法只会结束当前的 RunLoop 调用，而不会结束后续的调用。也就意味着 如果你是用方法一也就是 run的方式启动 RunLoop，那么这个 RunLoop 不会被退出，因为它会不断的启动，因为run 底层是不断（循环）调用runMode:beforeDate:来达到运行目的。如果你是使用runUntilDate:启动的，那么超时结束后会自动终止 RunLoop，如果是runMode:beforeDate:那么你可以精确的控制 RunLoop 的停止。

RunLoop 应用

RunLoop 用途广泛，如 AutoreleasePool，PerformSelecter，GCD，AsyncDisplayKit等都有涉及到，更多神秘等着我们去探索。

后话

根据 RunLoop 我们可以完成一个主线程卡顿的监控工具，在计划中，完成后会贴出地址。