Runloop

RunLoop 是 iOS开发中非常基础的一个概念，这篇文章先从基础例子入手，分析 CFRunLoop 的源码，介绍 RunLoop 的概念以及底层实现原理，最后通过检测卡顿的例子结束runloop讲解

一、runloop最重要的三个函数

- (void)run; // 进入处理事件循环，如果没有事件则立刻返回。注意：主线程上调用这个方法会导致无法返回（进入无限循环，虽然不会阻塞主线程），因为主线程一般总是会有事件处理。
- (void)runUntilDate:(NSDate *)limitDate; //同run方法，增加超时参数limitDate，避免进入无限循环。使用在UI线程（亦即主线程）上，可以达到暂停的效果。
- (BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate; //等待消息处理，好比在PC终端窗口上等待键盘输入。一旦有合适事件（mode相当于定义了事件的类型）被处理了，则立刻返回；类同run方法，如果没有事件处理也立刻返回；是否事件处理由返回布尔值判断。同样limitDate为超时参数。

- (void)threadWait
{
    stopFlag = NO;
    NSLog(@"Start a new thread");
    [NSThread detachNewThreadSelector:@selector(newThreadProc) toTarget:self withObject:nil];
    while (!stopFlag) {
        NSLog(@"Beginrunloop");
        BOOL finish = [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        NSLog(@"dealEvent = %@, Endrunloop", finish == YES ? @"YES": @"NO");
    }
    NSLog(@"OK");
}
- (void)newThreadProc
{
    NSLog(@"Enter newThreadProc");
    for (NSInteger i = 0; i < 10; i++) {
        NSLog(@"In new Threadproc count = %ld", i);
        sleep(1);
    }
//    stopFlag = YES;
    [self performSelectorOnMainThread: @selector(setEnd)
                           withObject: nil
                        waitUntilDone: NO];
    NSLog(@"Exit new ThreadProc");
}
-(void)setEnd{
    stopFlag = YES;
}

2018-01-02 17:33:15.868650+0800 RunloopTest[96462:6747158] Start a new thread
2018-01-02 17:33:15.868855+0800 RunloopTest[96462:6747158] Beginrunloop
2018-01-02 17:33:15.869007+0800 RunloopTest[96462:6747390] Enter newThreadProc
2018-01-02 17:33:15.869118+0800 RunloopTest[96462:6747390] In new Threadproc count = 0
2018-01-02 17:33:15.869855+0800 RunloopTest[96462:6747158] dealEvent = YES, Endrunloop
2018-01-02 17:33:15.869955+0800 RunloopTest[96462:6747158] Beginrunloop
2018-01-02 17:33:15.870145+0800 RunloopTest[96462:6747158] dealEvent = YES, Endrunloop
2018-01-02 17:33:15.870228+0800 RunloopTest[96462:6747158] Beginrunloop
2018-01-02 17:33:16.336256+0800 RunloopTest[96462:6747158] dealEvent = YES, Endrunloop
2018-01-02 17:33:16.336401+0800 RunloopTest[96462:6747158] Beginrunloop
2018-01-02 17:33:16.869622+0800 RunloopTest[96462:6747390] In new Threadproc count = 1
2018-01-02 17:33:17.872758+0800 RunloopTest[96462:6747390] In new Threadproc count = 2
2018-01-02 17:33:18.875654+0800 RunloopTest[96462:6747390] In new Threadproc count = 3
2018-01-02 17:33:19.878071+0800 RunloopTest[96462:6747390] In new Threadproc count = 4
2018-01-02 17:33:20.880257+0800 RunloopTest[96462:6747390] In new Threadproc count = 5
2018-01-02 17:33:21.882079+0800 RunloopTest[96462:6747390] In new Threadproc count = 6
2018-01-02 17:33:22.887392+0800 RunloopTest[96462:6747390] In new Threadproc count = 7
2018-01-02 17:33:23.892905+0800 RunloopTest[96462:6747390] In new Threadproc count = 8
2018-01-02 17:33:24.894575+0800 RunloopTest[96462:6747390] In new Threadproc count = 9
2018-01-02 17:33:25.896342+0800 RunloopTest[96462:6747390] Exit new ThreadProc
2018-01-02 17:33:25.896468+0800 RunloopTest[96462:6747158] dealEvent = YES, Endrunloop
2018-01-02 17:33:25.896643+0800 RunloopTest[96462:6747158] OK

1、主线程运行threadWait，运行结果打印顺序如上，运行期间界面可正常响应事件

2、dealEvent = YES, Endrunloop 打印多次，说明runMode:beforeDate:主线程在此期间多次处理事件并返回YES，可以替换成run函数尝试，发现Endrunloop不再打印，后续操作都被阻断不会执行

3、直接设置stopFlag=YES 和通过performSelectorOnMainThread设置，观察最后OK打印的时间是有时间差的

- (void)threadTest
{
    _hlThread = [[NSThread alloc] initWithTarget:self selector:@selector(subThreadEntryPoint) object:nil];
    [_hlThread start];
}
- (void)subThreadEntryPoint
{
    NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
    [runLoop addPort:[NSMachPort port] forMode:NSRunLoopCommonModes];
    NSLog(@"启动Runloop前--%@", runLoop.currentMode);
    [runLoop run];
}
- (void)subThreadOpetion
{
    NSLog(@"启动Runloop后--%@", [NSRunLoop currentRunLoop].currentMode);
    NSLog(@"%@----子线程任务开始",[NSThread currentThread]);
    [NSThread sleepForTimeInterval:3.0];
    NSLog(@"%@----子线程任务结束",[NSThread currentThread]);
}
-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    [self performSelector:@selector(subThreadOpetion) onThread:_hlThread withObject:nil waitUntilDone:NO];
}

2018-01-02 18:00:50.956511+0800 RunloopTest[97108:6795019] 启动Runloop前--(null)
2018-01-02 18:00:54.427331+0800 RunloopTest[97108:6795019] 启动Runloop后--kCFRunLoopDefaultMode
2018-01-02 18:00:54.427727+0800 RunloopTest[97108:6795019] {number = 3, name = (null)}----子线程任务开始
2018-01-02 18:00:57.433010+0800 RunloopTest[97108:6795019] {number = 3, name = (null)}----子线程任务结束
2018-01-02 18:00:57.433374+0800 RunloopTest[97108:6795019] 启动Runloop后--kCFRunLoopDefaultMode
2018-01-02 18:00:57.433650+0800 RunloopTest[97108:6795019] {number = 3, name = (null)}----子线程任务开始
2018-01-02 18:01:00.438874+0800 RunloopTest[97108:6795019] {number = 3, name = (null)}----子线程任务结束

1、主线程调用threadTest后，打印"启动Runloop前"，之后进入等待期间可以接受任何事件，touch屏幕会执行“启动Runloop后”,后续都执行完成以后继续等待...

2、子线程一直在运行，不会结束，可以替换run为另外两个函数，尝试结果

二、runloop的概念

RunLoop 实际上就是一个对象，这个对象管理了其需要处理的事件和消息，并提供了一个入口函数来执行事件循环的逻辑(即：run系列)。线程执行了这个函数后，就会一直处于这个函数内部 "接受消息->等待->处理" 的循环中，直到这个循环结束（比如传入 quit 的消息），函数返回。

iOS 系统中，提供了两个这样的对象：NSRunLoop 和 CFRunLoopRef

三、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 就是这样一个函数，其内部是一个 do-while 循环。当你调用 CFRunLoopRun() 时，线程就会一直停留在这个循环里；直到超时或被手动停止，该函数才会返回

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
    CFRunLoopModeRef _currentMode;    // Current Runloop Mode
    CFMutableSetRef _modes;           // Set
    ...
};

Source/Timer/Observer 被统称为 mode item，如果一个 mode 中一个 item 都没有，则 RunLoop 会直接退出，不进入循环。

关于source有两个版本：Source0 和 Source1

Source0 只包含了一个回调（函数指针），它并不能主动触发事件。使用时，你需要先调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理，然后手动调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件。
Source1 包含了一个 mach_port 和一个回调（函数指针），被用于通过内核和其他线程相互发送消息。这种 Source 能主动唤醒 RunLoop 的线程。如上面例子中的machport

四、利用runloop检测主线程卡顿

1、针对主线程建立runloop的observer

CFRunLoopObserverContext *context = {0, NULL, NULL, NULL};
CFRunLoopObserverRef runloopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, &monitorFunction, context);
CFRunLoopAddObserver(CFRunLoopGetMain(), runloopObserver, kCFRunLoopCommonModes);

2、runloop的observer函数中检测状态机的变化，并通知给监测者

dispatch_semaphore_t semaphore = [MonitorController shareInstance].semaphore;
[MonitorController shareInstance].activity = activity;
dispatch_semaphore_signal(semaphore);

3、根据定义的卡顿时间，判断处理事件时是否卡顿

 _semaphore = dispatch_semaphore_create(0);
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
        while (YES) {
            long waitTime = dispatch_semaphore_wait(_semaphore, dispatch_time(DISPATCH_TIME_NOW, 2000*NSEC_PER_MSEC));
            if(waitTime != 0)
            {
                if(_activity == kCFRunLoopBeforeSources || _activity == kCFRunLoopAfterWaiting)
                {
                    NSLog(@"发生卡顿");
                    [self logTrace];
                }
            }
        }
    });

Runloop

一、runloop最重要的三个函数

二、runloop的概念

三、runloop的内部逻辑

四、利用runloop检测主线程卡顿

你可能感兴趣的:(Runloop)