iOS 性能监控（二）—— 主线程卡顿监控

前言：
最近，在看戴铭老师关于 “性能监控” 相关的技术分享，感受收获不少。基于最近的学习，总结了一些性能监控相关的实践，并计划落地一系列 “性能监控” 相关的文章。
目录以下：
iOS 性能监控（一）—— CPU功耗监控
iOS 性能监控（二）—— 主线程卡顿监控
iOS 性能监控（三）—— 方法耗时监控

---

本篇将介绍iOS性能监控工具（QiLagMonitor）中与 “线程卡顿监控” 相关的功能模块。

1、了解线程的状态

主线程runloop默认注册了五个mode：kCFRunLoopDefaultMode、UITrackingRunLoopMode、UIInitializationRunLoopMode、GSEventReceiveRunLoopMode、kCFRunLoopCommonModes。

名称	做用
kCFRunLoopDefaultMode	App的默认 Mode，一般主线程是在这个 Mode 下运行的。
UITrackingRunLoopMode	界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其余 Mode 影响。
UIInitializationRunLoopMode	刚启动 App 时第进入的第一个 Mode，启动完成后就再也不使用。
GSEventReceiveRunLoopMode	接受系统事件的内部 Mode，一般用不到。
kCFRunLoopCommonModes	这是一个占位的 Mode。其实就是Default模式和UI模式之间切换使用。

其中，APPLE公开提供的Mode有两个：NSDefaultRunLoopMode（kCFRunLoopDefaultMode）、NSRunLoopCommonModes（kCFRunLoopCommonModes）。

而咱们的下节要介绍的主线程监控就是使用的就是NSRunLoopCommonModes（kCFRunLoopCommonModes）。

而后，runloop观察者：Runloop Observer有7种状态。

/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),
    kCFRunLoopBeforeTimers = (1UL << 1),
    kCFRunLoopBeforeSources = (1UL << 2),
    kCFRunLoopBeforeWaiting = (1UL << 5),
    kCFRunLoopAfterWaiting = (1UL << 6),
    kCFRunLoopExit = (1UL << 7),
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};
复制代码

分别表示：

状态	含义
kCFRunLoopEntry	运行runloop的入口。
kCFRunLoopBeforeTimers	Inside the event processing loop before any timers are processed.（在处理任何Timer计时器以前）
kCFRunLoopBeforeSources	Inside the event processing loop before any sources are processed.（在处理任何Sources源以前）
kCFRunLoopBeforeWaiting	Inside the event processing loop before the run loop sleeps, waiting for a source or timer to fire. This activity does not occur if CFRunLoopRunInMode is called with a timeout of 0 seconds. It also does not occur in a particular iteration of the event processing loop if a version 0 source fires.（在等待源Source和计时器Timer以前）
kCFRunLoopAfterWaiting	Inside the event processing loop after the run loop wakes up, but before processing the event that woke it up. This activity occurs only if the run loop did in fact go to sleep during the current loop.（在等待源Source和计时器Timer后，同时在被唤醒以前。）
kCFRunLoopExit	The exit of the run loop, after exiting the event processing loop. This activity occurs once for each call to CFRunLoopRun and CFRunLoopRunInMode.（runloop的出口）
kCFRunLoopAllActivities	runloop的全部状态。

PS：想了解更多的runloop信息，可查看以前彬哥写的博客。

2、iOS如何监控线程卡顿？

说一下QiLagMonitor中的大体实现思路。

• 首先，建立一个观察者runLoopObserver，用于观察主线程的runloop状态。 同时，还要建立一个信号量dispatchSemaphore，用于保证同步操做。

• 其次，将观察者runLoopObserver添加到主线程runloop中观察。

• 而后，开启一个子线程，而且在子线程中开启一个持续的loop来监控主线程runloop的状态。

• 若是发现主线程runloop的状态卡在为BeforeSources或者AfterWaiting超过88毫秒时，即代表主线程当前卡顿。 这时候，咱们保存主线程当前的调用堆栈便可达成监控目的。

图解原理：

• 正常状况下：

• 异常状况下：

3、QiLagMonitor中的具体实现

• 第一步，建立一个信号量dispatchSemaphore和观察者runLoopObserver。

//! 建立一个信号量，保证同步操做
    dispatchSemaphore = dispatch_semaphore_create(0); //! Dispatch Semaphore保证同步
    //! 建立一个观察者
    CFRunLoopObserverContext context = {0,(__bridge void*)self,NULL,NULL};
    runLoopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault,
                                              kCFRunLoopAllActivities,
                                              YES,
                                              0,
                                              &runLoopObserverCallBack,
                                              &context);
复制代码

同时当主线程的runloop状态发生改变时，会调用runLoopObserverCallBack方法，它内部会存储当前的runloop状态。同时，控制信号量。

static void runLoopObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info){
    QiLagMonitor *lagMonitor = (__bridge QiLagMonitor*)info;
    lagMonitor->runLoopActivity = activity;
    
    dispatch_semaphore_t semaphore = lagMonitor->dispatchSemaphore;
    dispatch_semaphore_signal(semaphore);
}
复制代码

• 第二步，将观察者添加到主线程runloop的common模式下观察。

//! 将观察者添加到主线程runloop的common模式下的观察中
    CFRunLoopAddObserver(CFRunLoopGetMain(), runLoopObserver, kCFRunLoopCommonModes);
复制代码

• 第三步，建立一个子线程，并开启一个持续的loop（其实就是个while死循环）来监控主线程的runloop状态。当runloop的状态持续为BeforeSources、AfterWaiting两个状态时，说明主线程卡顿，记录当前主线程调用堆栈。

//! 建立子线程监控
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        //! 子线程开启一个持续的loop用来进行监控
        while (YES) {
            long semaphoreWait = dispatch_semaphore_wait(self->dispatchSemaphore, dispatch_time(DISPATCH_TIME_NOW, STUCKMONITORRATE * NSEC_PER_MSEC));
            if (semaphoreWait != 0) {
                if (!self->runLoopObserver) {
                    self->timeoutCount = 0;
                    self->dispatchSemaphore = 0;
                    self->runLoopActivity = 0;
                    return;
                }
                //! 两个runloop的状态，BeforeSources和AfterWaiting这两个状态区间时间可以检测到是否卡顿
                if (self->runLoopActivity == kCFRunLoopBeforeSources || self->runLoopActivity == kCFRunLoopAfterWaiting) {
                    //! 出现三次出结果
                    if (++self->timeoutCount < 3) {
                        continue;
                    }
                    NSLog(@"monitor trigger");
                    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                        NSString *stackStr = [QiCallStack callStackWithType:QiCallStackTypeMain];
                        QiCallStackModel *model = [[QiCallStackModel alloc] init];
                        model.stackStr = stackStr;
                        model.isStuck = YES;
                        [[[QiLagDB shareInstance] increaseWithStackModel:model] subscribeNext:^(id x) {}];
                    });
                } // end activity
            }// end semaphore wait
            self->timeoutCount = 0;
        }// end while
    });
复制代码

最后，本系列我是站在iOS业界巨人的肩膀上完成的，感谢戴铭老师精彩的技术分享。 祝你们学有所成，工做顺利。
另附上，戴铭老师课程连接：《iOS开发高手课》，谢谢！