iOS卡顿优化

- (void)drawCornerPicture{
    UIImageView *imageView = [[UIImageView alloc] initWithFrame:CGRectMake(200, 400, 200, 200)];
    imageView.image = [UIImage imageNamed:@"1"];
    // 开启图片上下文
    // UIGraphicsBeginImageContext(imageView.bounds.size);
    // 一般使用下面的方法
    UIGraphicsBeginImageContextWithOptions(imageView.bounds.size, NO, 0);
    // 绘制贝塞尔曲线
    UIBezierPath *bezierPath = [UIBezierPath bezierPathWithRoundedRect:imageView.bounds cornerRadius:100];
    // 按绘制的贝塞尔曲线剪切
    [bezierPath addClip];
    // 画图
    [imageView drawRect:imageView.bounds];
    // 获取上下文中的图片
    imageView.image = UIGraphicsGetImageFromCurrentImageContext();
    // 关闭图片上下文
    UIGraphicsEndImageContext();
    [self.view addSubview:imageView];
}

- (void)circleImage{
    UIImageView *imageView = [[UIImageView alloc] initWithFrame:CGRectMake(200, 400, 200, 200)];
    imageView.image = [UIImage imageNamed:@"001.jpeg"];
    // NO代表透明
    UIGraphicsBeginImageContextWithOptions(imageView.bounds.size, NO, 0.0);
    // 获得上下文
    CGContextRef ctx = UIGraphicsGetCurrentContext();
    // 添加一个圆
    CGRect rect = CGRectMake(0, 0, imageView.bounds.size.width, imageView.bounds.size.height);
    CGContextAddEllipseInRect(ctx, rect);
    // 裁剪
    CGContextClip(ctx);
    // 将图片画上去
//    [imageView drawRect:rect];
    [imageView.image drawInRect:rect];
    imageView.image = UIGraphicsGetImageFromCurrentImageContext();
    // 关闭上下文
    UIGraphicsEndImageContext();
    [self.view addSubview:imageView];
}

@implemention ViewController {
    UILable *_fpsLabel;
    CADisplayLink *_link;
    NSTimeInterval _lastTime;
    float _fps;
}

- (void)startMonitoring {
    if (_link) {
        [_link removeFromRunloop:[NSRunloop mainRunloop] forMode:NSRunloopCommonModes];
        [_link invalidate];
        _link = nil;
    }
    _link = [CADisplayLink displayLinkWithTarget:self selector:@selector(fpsDisplayLinkAction:)];
    [_link addToRunloop:[NSRunloop mainRunloop] forMode:NSRunloopCommonModes];
}

- (void)fpsDisplayLinkAction:(CADisplaylink *)link {
    if (_lastTime == 0) {
        _lastTime = link.timestamp;
        return;
    }
    
    self.count++;
    NSTimeInterval delta = link.timestamp - _lastTime;
    if (delta < 1) return;
    _lastTime = link.timestamp;
    _fps = _count / delta;
    self.count = 0;
    _fpsLabel.text = [NSString stringWithFormat:@"FPS: %.0f", _fps];
}

/// 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);
    
    /// 5. GCD处理main block;
    _CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);
    
    /// 6. 通知Observers即将进入休眠，
    /// 此处有Observer释放并新建AutorealasePool: _objc_autorelasePoolPop(); _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);

// 开始监听
- (void)startMonitor {
    if (observer) {
        return;
    }
    
    // 创建信号
    semaphore = dispatch_semaphore_create(0);
    NSLog(@"dispatch_semaphore_create: %@", [PerformanceMonitor getCurTime];);
    
    // 注册Runloop状态观察
    CFRunloopContextObserver context = {0, (__bridge void*)self, NULL, NULL};
    // 创建Run loop observer对象
    //第一个参数用于分配observer对象的内存
    //第二个参数用以设置observer所要关注的事件，详见回调函数myRunLoopObserver中注释
    //第三个参数用于标识该observer是在第一次进入run loop时执行还是每次进入run loop处理时均执行
    //第四个参数用于设置该observer的优先级
    //第五个参数用于设置该observer的回调函数
    //第六个参数用于设置该observer的运行环境
    observer = CFRunloopObserverCreate(kCFAllocatorDefault,
                                       kCFRunLoopAllActivities,
                                       YES,
                                       0,
                                       &runLoopObserverCallBack,
                                       &context);
    CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
    
    // 在子线程监控时长
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        while (YES) { // 有信号的话，就查询Runloop的状态
            // 假定连续5次超时50ms认为卡顿(当然也包含了单次超时250ms)
            // 因为下面runloop状态改变的回调方法runLoopObserverCallback中会将信号量递增1，所以每次runloop状态改变后，下面的语句都会执行一次。
            // dispatch_semaphore_wait: Returns zero on success, or non-zero if timeout occured.
            long st = dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 50 * NSEC_PER_MSEC));
            NSLog(@"dispatch_semaphore_wait: st=%ld, time:%@", st, [self getCurTime]);
            
            if (st != 0) { // 信号量超时了 - 即 runloop 的状态长时间没有发生变更，长期处于某一个状态下
                if (!observer) {
                    timeoutCount = 0;
                    semaphore = 0;
                    activity = 0;
                    return;
                }
                
                NSLog(@"st = %ld, activity = %lu, timeoutCount = %d, time: %@", st, activity, timeoutCount, [self getCurTime]);
                
                // kCFRunLoopBeforeSources - 即将处理Sources
                // kCFRunLoopAfterWaiting - 刚从休眠中唤醒
                // 获取kCFRunLoopBeforeSources和kCFRunLoopBeforeWaiting，再到kCFRunLoopAfterWaiting的状态就可以知道是否有卡顿的情况。
                // kCFRunLoopBeforeSources: 停留在这个状态，表示在做很多事情
                if (activity == kCFRunLoopBeforeSources ||
                   activity == kCFRunLoopAfterWaiting) {
                    if (++timeoutCount < 5) {
                        continue; // 不足5次，直接continue当次循环，不将timeoutCount置为0
                    }
                    
                    // 收集Crash信息也可用于实时获取各线程的调用堆栈
                    PLCrashReporterConfig *config = [[PLCrashReporterConfig alloc] initWithSignalHandlerType:PLCrashReporterSignalHandlerTypeBSD symbolicationStrategy:PLCrashReporterSymbolicationStrategyAll];
                    
                    PLCrashReporter *crashReporter = [[PLCrashReporter alloc] initWithConfiguration:config];
                    
                    NSData *data = [crashReporter generateLiveReport];
                    PLCrashReport *reporter = [[PLCrashReport alloc] initWithData:data error:NULL];
                    NSString *report = [PLCrashReportTextFormatter stringValueForCrashReport:reporter withTextFormat:PLCrashReportTextFormatiOS];
                    
                    NSLog(@"---------卡顿信息\n%@\n--------------",report);
                }
            }
            NSLog(@"dispatch_semaphore_wait timeoutCount = 0，time:%@",[self getCurTime]);
            timeoutCount = 0;
        };
    };
}

private class AppPingThread: Thread {
    private let semaphore = DispathchSemaphore(value: 0)
    // 判断主线程是否卡顿的标志
    private var isMainThreadBlock = True
    
    private var threshould: Double = 0.4
    fileprivate var handler: (() -> Void)?
    
    func start(threshould: Double, handler: @escaping AppPingThreadCallback) {
        self.handler = handler
        self.threshould = threshould
        self.start()
    }
    
    override func main() {
        while self.isCancelled == false {
            self.isMainThreadBlock = true
            // 主线程去重置标识
            DispatchQueue.main.async {
                self.isMainThreadBlock = false
                self.semaphore.signal()
            }
            
            Thread.sleep(forTimeInterval: self.threshould)
            // 若标志未重置成功则说明再设置的阈值时间内主线程未响应
            if self.isMainThredBlock {
                // 采集卡顿调用栈信息
                self.handler?()
            }
            
            _ = self.semaphore.wait(timeout: DispatchTime.distantFuture)
        }
    }
}