美文网首页iOS 应用层iOS 性能系统层知识
RunLoop 监控卡顿为什么要用kCFRunLoopBefor

RunLoop 监控卡顿为什么要用kCFRunLoopBefor

作者: YM_1 | 来源:发表于2017-08-04 10:16 被阅读596次

    最近看了runloop应用中监控卡顿的一些博客,很多人都提到了通过kCFRunLoopBeforeSources和kCFRunLoopAfterWaiting状态判定卡顿,当时很迷惑,通过分析明白了原因,特此记录下。
    网上大部分代码和下面基本相同,自己理解的难点是 RunLoop 监控卡顿为什么要用kCFRunLoopBeforeSources和kCFRunLoopAfterWaiting状态判定,在网上找答案也没有很好的解释,通过自己的分析明白了下面代码的意义。

    先说一下我对主线程卡顿的理解,就是主线程在 Runloop 的某个阶段进行长时间的耗时操作。

    RunLoop 顺序
                     1、进入
                     
                     2、通知Timer
                     3、通知Source
                     4、处理Source
                     5、如果有 Source1 调转到 11
                     6、通知 BeforWaiting
                     7、wait
                     8、通知afterWaiting
                     9、处理timer
                     10、处理 dispatch 到 main_queue 的 block
                     11、处理 Source1、
                     12、进入 2
                     
                     13、退出
    

    理清楚Runloop的运行机制,就很容易明白处理事件主要有两个时间段 kCFRunLoopBeforeSources 发送之后和 kCFRunLoopAfterWaiting 发送之后。

    dispatch_semaphore_t 是一个信号量机制,信号量到达、或者 超时会继续向下进行,否则等待,如果超时则返回的结果必定不为0,信号量到达结果为0。

    利用这个特性我们判断卡顿出现的条件为 在信号量发送 kCFRunLoopBeforeSources和kCFRunLoopAfterWaiting后进行了大量的操作,在一段时间内没有再发送信号量,导致超时。也就是说主线程通知状态长时间的停留在这两个状态上了。转换为代码就是判断有没有超时,超时了,判断当前停留的状态是不是这两个状态,如果是,就判定为卡顿。

    这样就能解释通为什么要用这两个信号量判断卡顿。这么一个简单的问题,思路转不过来就绕进去了,现在回看感觉这个很简单,也是耗了一天时间。

    代码如下:

    头文件

    + (instancetype)shareInstance;
    
    - (void)beginMonitor;
    - (void)stopMonitor;
    

    m文件变量定义

    @interface YMSubThreadMonitor()
    {
        CFRunLoopObserverRef ymObserver;
        
        @public     //@public 外部能访问到
        CFRunLoopActivity currentRunloopActivity;
        dispatch_semaphore_t semaphore;
        
    }
    
    @end
    
    @implementation YMSubThreadMonitor
    + (instancetype)shareInstance{
        static dispatch_once_t onceToken;
        static YMSubThreadMonitor *monitor;
        dispatch_once(&onceToken, ^{
            monitor = [YMSubThreadMonitor new];
        });
        return monitor;
    }
    

    主要代码

    - (void)beginMonitor{
        
        if (ymObserver) {
            return;
        }
        
        //创建观察者
        /**
         typedef struct {
         CFIndex    version;
         void * info;
         const void *(*retain)(const void *info);
         void   (*release)(const void *info);
         CFStringRef    (*copyDescription)(const void *info);
         } CFRunLoopObserverContext;
         */
        CFRunLoopObserverContext context = {0,(__bridge void*)self,NULL,NULL,NULL};
        
        /**
         CFRunLoopObserverRef CFRunLoopObserverCreate(
         CFAllocatorRef allocator,
         CFOptionFlags activities,
         Boolean repeats,
         CFIndex order,
         CFRunLoopObserverCallBack callout,
         CFRunLoopObserverContext *context
         );
         */
        ymObserver = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, &mObservercallBack, &context);
        
        //向主线程添加 观察者
        CFRunLoopRef mainLoop = CFRunLoopGetMain();
        CFRunLoopAddObserver(mainLoop, ymObserver, kCFRunLoopCommonModes);
        
        //创建子线程开始监控
        dispatch_queue_t monitorQueue = dispatch_queue_create("com.ym.monitorQueue", DISPATCH_QUEUE_CONCURRENT);
        
        //创建同步信号量
        semaphore = dispatch_semaphore_create(0);
        
        dispatch_async(monitorQueue, ^{
            
            //开一个持续的  loop
            while (YES) {
                //超时时间设置
                dispatch_time_t outTimer = dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC);
                
                //信号量到达、或者 超时会继续向下进行,否则等待、
                long result = dispatch_semaphore_wait(semaphore, outTimer);
                
                if (result != 0) {
                    
                    //超时,判断最后停留的信号量是哪一个,是否处理为卡顿现象。
                    if (!ymObserver) {
                        NSLog(@"--NO ymObserver---");
                        semaphore = 0;
                        currentRunloopActivity = 0;
                        return ;
                    }
                    
                    //判断当前 监听到的 信号(也就是说上一个信号量超过2秒没有更新,故卡顿)
                    /**
                     RunLoop 顺序
                     1、进入
                     
                     2、通知Timer
                     3、通知Source
                     4、处理Source
                     5、如果有 Source1 调转到 11
                     6、通知 BeforWaiting
                     7、wait
                     8、通知afterWaiting
                     9、处理timer
                     10、处理 dispatch 到 main_queue 的 block
                     11、处理 Source1、
                     12、进入 2
                     
                     13、退出
                     
                     由上可知,主要处理任务阶段为 AfterWaiting 之后、通知Source之后
                     如果 发送 AfterWaiting 后在限定时间内没有发送其他信号量,
                     可以认为这中间存在耗时操作,判定为卡顿。
                     同理 通知Source之后 超时也可以判定为卡顿。
                     
                     */
                    if (currentRunloopActivity == kCFRunLoopBeforeSources || currentRunloopActivity == kCFRunLoopAfterWaiting) {
                        //出现卡顿、进一步处理
                        NSLog(@"--卡顿啦----From 卡顿监控线程");
                        // log current stack info
                        continue;
                    }
                }
                
                NSLog(@"--系统运行良好--From 卡顿监控线程");
            }
        });
        
    }
    
    - (void)stopMonitor{
        
        if (!ymObserver) {
            return;
        }
        
        CFRunLoopRemoveObserver(CFRunLoopGetMain(), ymObserver, kCFRunLoopCommonModes);
        CFRelease(ymObserver);
        ymObserver = NULL;
        
    }
    
    #pragma mark -Private Method
    
    /**
     * 观察者回调函数
     */
    static void  mObservercallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info){
        //每一次监测到Runloop发送通知的时候,都会调用此函数
        //在此过程修改当前的 RunloopActivity 状态,发送同步信号。
        YMSubThreadMonitor *monitor = (__bridge YMSubThreadMonitor *)info;
        
        monitor->currentRunloopActivity = activity;
        dispatch_semaphore_t tempSemaphore = monitor->semaphore;
        dispatch_semaphore_signal(tempSemaphore);
    }
    

    相关文章

      网友评论

        本文标题:RunLoop 监控卡顿为什么要用kCFRunLoopBefor

        本文链接:https://www.haomeiwen.com/subject/csqvlxtx.html