RunLoop

****简介****
RunLoop在OS X/ iOS中一项比较基础的知识点,虽然基础,但是十分重要。它与线程息息相关,是用于处理到来事件的循环处理机制,可以理解为消息队列,当有事件需要处理的时候,RunLoop会使得线程在持续运行状态,没有任务的时候会让线程进入休眠状态。每一条线程都有一条与之对应的RunLoop(但是不仅限于一条,可以在RunLoop内嵌套另一个RunLoop)。

本文尝试讲解RunLoop的一些原理方面的知识,同时会介绍几个RunLoop的具体应用案例,基于RunLoop在cocoa层的API(NSRunLoop)网上有许多参考资料,翻阅官方reference也能中得到,在这里就不花篇幅介绍了。

****RunLoop结构****
RunLoop的实现可以用伪代码表示为:

int retVal = 1
fun __CFRunLoopRun(CFRonLoopRef rl) {
      var msg
      do {
             msg = get_next_msg
            if (msg) {
                rl.wakeUp()
                handle(msg)
            }else {
                rl.sleep()
            }
            retVaule =  msg==quit || msg==timeout 0 : 1
      }while (retVal == 1)
}

这个模型被称为Event Loop,也可以理解成消息队列。RunLoop 实际上就是一个对象,这个对象管理了其需要处理的事件和消息,并提供了一个入口函数来执行上面 Event Loop 的逻辑。线程执行了这个函数后,,就会一直处于这个函数内部 "接受消息->等待->处理" 的循环中,直到这个循环结束(比如传入 quit 的消息),函数返回。

在OS X和iOS中,苹果提供了两种类型的API:

  • cocoa层 : NSRunLoop

  • CoreFoundation : CFRunLoopRef

显而易见,NSRunLoop是对CFRunLoopRef在OC上面向对象的封装,但是NSRunLoop不是线程安全的,而CFRunLoopRef是线程安全的。
整个CoreFoundation是开源的,可以在这里下载源码。

这个CFRunLoop有五大类:

  • CFRunLoopRef :

一个runLoop对象

  • CFRunLoopMod

一个RunLoop包含若干个Mode,Mode中又包含若干个Source/Timer/Observer,如果切换Mode,只能退出当前的RunLoop,主要是为了分隔开不同组的Source/Timer/Observer。

  • CFRunLoopObserverRef

RunLoop状态的观察者,每一个观察者都包含一个回调(指针函数),当RunLoop的状态发生变化时,观察者就能通过回调接收这个变化。
可以观察到的RunLoop的状态时间点有:

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
  kCFRunLoopEntry = (1UL << 0),        //即将进入RunLoop
  kCFRunLoopBeforeTimers = (1UL << 1), //即将触发Timer
  kCFRunLoopBeforeSources = (1UL << 2),//即将触发Source
  kCFRunLoopBeforeWaiting = (1UL << 5),//即将进入休眠
  kCFRunLoopAfterWaiting = (1UL << 6), //即将被换新
  kCFRunLoopExit = (1UL << 7),         //即将退出
};
  • CFRunLoopSourceRef
    事件的产生的地方。

有两个版本的Source:

  • *Source0 *:只包含一个回调函数指针,使用时需要将事件标记为待处理:CFRunLoopSourceSignal(source)
    ,再调用CFRunLoopWakeUP(runloop)
    来唤醒RunLoop,使其处理整个事件

  • *Source1 *:包含一个用于内核和其他线程发送消息的方法:mach_port,这种source能主动唤醒RunLoop,具体原因看底下会讲到的mach_msg()

  • CFRunLoopTimerRef
    基于时间的触发器,与NSTimer可以混用,包含一个回调,当其加入RunLoop时,RunLoop会注册时间点,等到时间点到了RunLoop会被唤醒处理回调时间。

Source/Timer/Observer被统称为mode item,一个item可以加入不同的RunLoop,但是重复添加到同一个Runloop是不会起作用的;如果一个RunLoop不包含Source/Timer(只包含Observer也不行),这个RunLoop是不会进入循环的。

RunLoop代码
CFRunLoopMode和CFRunLoop的关系大致为:

struct __CFRunLoopMode {
    ...
    CFStringRef _name;//mode的名字:kCFRunLoopDefaultMode
    CFMutableSetRef _source0;
    CFMutableSetRef _source1;
    CFMutableArrayRef _observers;
    CFMutableArrayRef _timers;
    ...
}

struct __CFRunLoop {
    ...
    CFMutableSets _commonModes;  //存放具有"common"标示的mode
    CFMutableSets _commonModeItems;
    CFRunLoopModeRef _currentMode;
    CFMutableSetRef _modes
    ...
}

__commonModesItems里面存放observer/timer/source,当RunLoop的状态发生变化时,RunLoop会将这个集合里面的所有mode item同步到具有"common"标示的mode中。
应用场景:我们知道,一个timer在NSDefaultMode
下被触发,如果这个时候拖动scrollview的话,这个timer就失效了,因为拖动scrollview,RunLoop的mode切换为UITrackingRunLoopMode
。如果想要让一个定时器在两个模式下都有效有两种方法:1、将它加入到两个mode中;2、将timer加入到顶层的RunLoop的commonModeItems集合中,RunLoop会自动将这个集合中的所有item同步到具有"common"标示的mode

****RunLoop与线程****
线程与RunLoop是一一对应关系,其关系保存在一个全局字典中,但是不是说一条线程中只能有一个RunLoop,你可以通过在RunLoop中嵌套另一个RunLoop达到一个线程中多个RunLoop的目的。

苹果不允许直接创建RunLoop,只能通过提供的两个方法获取当前线程的RunLoop和主线程的RunLoop:CFRunLoopGetCurrent() 和CFRunLoopGetMain() 。当你获取RunLoop的时候,如果没有这个RunLoop,那么系统会创建一个RunLoop返回给你,线程刚创建时是没有RunLoop的,RunLoop的创建发生在第一次获取的时候。

获取线程RunLoop的代码大致如下:

CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    if (!loop) 
            CFRunLoopRef newLoop = __CFRunLoopCreate(t);
            loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    if (!loop) 
            CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
            loop = newLoop;
    return loop;
}

****RunLoop流程:****

//1、通知observer即将进入RunLoop:
__CFRunLoopDoObserver(rl, currentMode, KCFRunLoopEntry);

__CFRunLoopRun(CFRunLoopRel rl, sourchHandleThisLoop) {
    int retval = 1;
    do {

        //2、通知observer:即将处理Timer
        __CFRunLoopDoObserver(rl, currentMode, kCFRunLoopBeforeTimers);

        //3、通知observer:即将处理Source0
        __CFRunLoopDoSource(rl, currentMode, kCFRunLoopBeforeSources);

        //4、RunLoop触发source0
        __CFRunLoopDoObserver(rl, currentMode, stopAfterHandler);

        //5、如果有source1且是处理ready状态,跳转到 9 ,直接处理source1然后跳转去处理消息
        if (__Source0DidDispatchPortLastTime) {
            Boolean hasMag = __CFRunLoopServiceMachPort(dispatchPort, &msg);
            if (hasMas) goto handleMsg
        }

        //6、如果没有待处理的消息,通知observer,即将进入休眠
        if (!__soure0DidDispatchPortLastTime) {
            __CFRunLoopDoObserver(rl, currentMode, kCFRunLoopBeforeWaiting);
        }

        //7、RunLoop进入休眠,除非有以下情况才会从休眠中被唤醒:
        1)timer设定的时间点到了
        2)基于port的source事件
        3)分发到主队列RunLoop的任务

        //8、通知observer线程刚刚被唤醒
        __CFRunLoopDoObserver(rl, currentMode, kCFRunLoopAfterWaiting);

        //9、RunLoop被唤醒,处理消息:
        if (msg_is_timer) {
            CFRunLoopDoTimer(rl, currentMode, mach_absoluteTime());
        }else if (msg_is_dispatch) {
            __CFRUNLOOP_IS_SERVICING_MAIN_DISAPTCH_QUEUE(msg)
        }else {
            CFRunLoopSourceRef   source1 = __CFRunLoopFindSourceForMachPort(rl, currentMode, livePort);
            sourceDoHandleThisPort = __CFRunLoopDoSource1(rl, currentMode, source1);
            if (surceDoHnadleThisPort) {
                mach_msg(reply, MACH_SEND_MSG, reply);
        }   

        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;
            } 
        } while (retVal == 1)
}

//10、通知observer,即将推出RunLoop
__CFRunLoopDoObserver(rl, currentMode, kCFRunLoopExit);

****RunLoop底层实现****
RunLoop的核心是基于mach_port,进入休眠期间调用的是mach_msg()方法,
关于mach:

mach是OS X/iOS 系统架构XNU内核,作为它作为一个微内核,仅提供处理器的调度,IPC等非常少量的服务。
在mach中的对象不能直接调用,只能通过消息传递的方式实现对象间的通信。
有关mach的通信如何使用参照[这里](https://segmentfault.com/a/1190000002400329)。
消息在mach中是最基础的概念,在两个端口直接传递,行程了mach 的IPC核心。
从mach 的源码信息中可以看出mach其实就是一个二进制包数据,其头部包含了当前端口local_port
和目标端口remote_port
。
苹果提供了在cocoa层的对mach端口操作API-NSMachport。

在APP静止的时候点击暂停可以从调用栈信息里面看到:

1638754-89db6f6d46061ee7.png.jpeg

系统在用户态时会调用mach_msg_trap()会触发陷阱机制,切换到内核态,在内核态下实际上是调用了mach_msg()来实现完成实际工作。
大体过程是这样的:

1638754-1eec76243bcab529.png.jpeg

****RunLoop的五个Mode****
RunLoop包含五个Mode,分别为

kCFRunLoopDefaultMode 默认的mode,主线程在此mode下实现
UITrackingRunLoopMode 追踪scrollview的触摸滑动
UIInitializationRunLoopMode 刚启动APP时的第一个mode,只在刚启动时有效,之后后切换为default mode
GSEventReceiveRunLoopMode 系统事件的内部mode
kCFRunLoopCommonMode 占位mode,无实际作用

****RunLoop的调用函数****
RunLoop在执行中,是通过一长串的函数进行回调的,例如:
即将出发timer的回调:
CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION(kCFRunLoopBeforeTimers),
即将出发source回调:
CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION(source0);
......
这些函数都能在调用栈信息中找到。

在RunLoop中,这些函数的执行顺序是这样的:

/// 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.1 如果是被Timer唤醒的,回调Timer
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(timer);

        /// 9.2 如果是被dispatch唤醒的,执行所有调用 dispatch_async 等方法放入main queue 的 block
        __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(dispatched_block);

        /// 9.3 如果如果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);
}

note:autoreleasepool的创建和释放是在RunLoop的休眠和下一次启动之间进的。
****RunLoop在cocoa中的应用****
事件传递与手势识别
对于硬件事件(触摸、锁屏、摇晃)的处理,苹果注册了一个基于port的source1,它的回调函数是__IOHIDEventSystemClientQueueCallback()
,事件发生后,系统将事件包装成IOHIDEvent
对象,并由mach port分配到对应的APP进程中,随后触发source1的回调,并调用_UIApplicationHandleEventQueueCallback()
进行内部分发,其中包括识别 UIGesture/处理屏幕旋转/发送给 UIWindow 等,接下来发生的 事件传递响应链 了。
对于手势识别:当_UIApplicationHandleQueueCallback()
接收到手势的时候,会将TouchBegin等事件的回调打断,随后会将这个手势标记为待处理状态,同时注册一个observer,检测BeforeWaiting状态,当RunLoop即将进入休眠时,其内部会获取到刚才所有标记为待处理的手势,执行_UIGestureRecognizerUpdateQueue()

****Autorealease****
iOS中autorelease变量什么时候释放,应该分为两种情况:

  • 手动释放@autoreleasepool { }中的自动释放变量在当前大括号作用域结束时释放;
  • 系统释放:在当前RunLoop本次Loop结束后释放;

autorelease原理:

主线程注册了两个observer1,observer2,这两个observer的回调函数都是__wrapRunLoopWithAutoReleasePoolHandler()。

observer1监测Entry状态,当进入RunLoop时,调用_obj_autoreleasepool_push()方法创建一个新的autoreleasepool,这个observer的优先级最高,确保autoreleasepool的创建在所有的回调之前;

observer2监测BeforeWaiting状态,当RunLoop即将进入休眠时,回调中先调用_objc_autoreleasepool_pop()方法将autoreleasepool里面的自动释放类型的变量释放,然后再调用_objc_autoreleasepool_push()方法创建一个新的autoreleasepool。同时observer2还会检测Exit状态,当退出RunLoop时调用_objc_autoreleasepool_pop()。这个observer的优先级最低,确保autoreleasepool的释放在所有的回调之后。

Autorelease的深层原理请参考:黑幕背后的Autorelease

****页面刷新****
当在操作 UI 时,比如改变了 Frame、更新了 UIView/CALayer 的层次时,或者手动调用了 UIView/CALayer 的 setNeedsLayout/setNeedsDisplay方法后,这个 UIView/CALayer 就被标记为待处理,并被提交到一个全局的容器去。

苹果注册了一个 Observer 监听 BeforeWaiting(即将进入休眠) 和 Exit (即将退出Loop) 事件,回调去执行:
_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv()。这个函数里会遍历所有待处理的 UIView/CAlayer 以执行实际的绘制和调整,并更新 UI 界面。在这个函数之后就在屏幕上看到UI的变化

****Timer****
可以说没有RunLoop就不可能实现定时器的功能。定时器的大致原理:设定一个时间点,将定时器加入RunLoop中,等到达设定的时间点的时候回唤醒线程处理回调。

****PerfromSeletor:afterDelay:****
如果当前线程中没有RunLoop这个方法是不会有效的,本质上是在当前线程的RunLoop中添加一个定时器,当时间点到了会唤醒RunLoop执行回调。

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

有一种说法,说RunLoop的timer和GCD中的timer是一个东西,其实不是的,但是GCD的timer和RunLoop是怎么协调工作的,具体还不太清楚。

****RunLoop的实际使用案例****
AFNetWorking
在AFN中的:

+ (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;
}

在上面的代码中,AFN创建了一个RunLoop,并且加入了一个mach port,但是这个port什么事情也没做,主要作用是为了让RunLoop处于常驻状态,否则这个RunLoop马上就会退出了,所以,这也是创建一个常驻服务线程的方法。

****滚动视图中延迟加载图片****
在tableview或者collection view中,如果要在停止拖拽的时候再加载图片,最直接的想法是,通过tableview和colletionview的isDragging等属性来进行判断,但是使用RunLoop来实现这一功能就不需要那么麻烦:

[imgView performSelector:@selector(loadImage:)
              withObject:image
                 inModeS:@[NSDefaultRunLoopMode]];

推荐阅读更多精彩内容