dailyLearning -- runLoop

作者: 树根曰 | 来源:发表于2018-11-22 16:44 被阅读0次

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 中;

参考资料：