关于iOS的卡顿方案，网上很多文章都有阐述，这里说一下一种之前大表哥谈起的一种实现方式，这种方式算是挺优雅的。
一.卡顿检测
1.主要变量介绍
static CFRunLoopActivity _MainRunLoopActivity = 0;
NSRunLoop *_monitorRunLoop;
NSInteger _count;
BOOL _checked;
NSTimer *_monitorTimer;
NSString *_dumpCatonString;
_MainRunLoopActivity: 记录主线程runloop当前状态_monitorRunLoop:监听线程的runloop_count:记录定时器回调的卡顿次数，如果卡顿次数超过5次，也就是0.5秒，就认为卡顿。_checked:判断是否将需要执行的block注入主线程的runloop._dumpCatonString:当_count次数为3是输出堆栈日志信息，然后在超过5次，被认为卡顿的时候，比较两次堆栈日志内容，确定是否同一原因引起卡顿。
2.主要思路分析:
- 首先监听主线程的
runloop回调，并用一个变量记录_MainRunLoopActivity记录当前主线程runloop的状态。
- (void)startMonitor {
if (!_monitorRunLoop) {
CFRunLoopObserverContext context = { 0, nil, NULL, NULL };
CFRunLoopObserverRef observer = CFRunLoopObserverCreate(kCFAllocatorDefault,
kCFRunLoopAllActivities,
YES,
0,
&_MainRunLoopObserverCallBack,
&context);
CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
CFRelease(observer);
[self startFpsTimer];
[NSThread detachNewThreadSelector:@selector(monitorThreadStart) toTarget:self withObject:nil];
}
}
- 同时开启
一条线程，这条线程启动runloop进行保活，同时在当前线程的runloop里面启动一个定时器，每隔0.1秒进行一次回调。
- (void)monitorThreadStart {
_monitorTimer = [NSTimer timerWithTimeInterval:1 / 10.f
target:self
selector:@selector(timerAction:)
userInfo:nil
repeats:YES];
_monitorRunLoop = [NSRunLoop currentRunLoop];
[_monitorRunLoop addTimer:_monitorTimer forMode:NSRunLoopCommonModes];
CFRunLoopRun();
}
- 在定时器的回调里面判断当前
主线程runloop状态_MainRunLoopActivity是否为kCFRunLoopBeforeWaiting,如果是kCFRunLoopBeforeWaiting(即将进入休眠)，就将_count置为0，如果不是kCFRunLoopBeforeWaiting，就判断是否向主线程的runloop注入block已经回调，如果回调就执行block注入，如果没有回调就将_count++，并判断是否触发卡顿，如果_count等于3，将堆栈日志输出到_dumpCatonString,如果_count大于5，触发卡顿，就判断两次输出日志是否一致，如果一致说明是同一个原因引起。
- (void)timerAction:(NSTimer *)timer {
if (_MainRunLoopActivity != kCFRunLoopBeforeWaiting) {
if (!_checked){
_checked = YES;
CFRunLoopPerformBlock(CFRunLoopGetMain(), kCFRunLoopCommonModes, ^{
self->_checked = NO;
self->_count = 0;
});
}
else {
++_count;
if (_count == 3) {
_dumpCatonString = [BSBacktraceLogger bs_backtraceOfMainThread];
}
if (_count > 5) {
_count = 0;
NSLog(@"卡住啦");
NSString *tmpCatonString = [BSBacktraceLogger bs_backtraceOfMainThread];
if ([_dumpCatonString isEqualToString:tmpCatonString]) {
NSLog(@"%@", tmpCatonString);
}
}
}
}
else{
_count = 0;
}
}
这里之所以对当前主线程runloop状态_MainRunLoopActivity是否为kCFRunLoopBeforeWaiting进行判断是因为向主线程runloop注入block，并不会唤醒处于休眠状态的主线程，只能等待runloop被唤醒之后，在runloop进入kCFRunLoopBeforeSources和kCFRunLoopAfterWaiting状态之后才会进行相关block处理。
runloop处理流程
二.FPS帧率计算
现阶段，常用的FPS监控基本都是居于CADisplayLink来实现的。
因为CADisplayLink的信号发射频率和屏幕的刷新频率一致，固定是1秒钟60次，也就是16.67毫秒一次，因此常用一个计数器来统计每一秒钟，进行了多少次回调，来算出当前FPS。
但CADisplayLink有一个缺点，一旦启用了CADisplayLink定时器，就算将frameInterval(iOS10之前)或preferredFramesPerSecond(iOS之后)设置为100，信号的发射频率依然是1秒钟60次，这样就会使得runloop处于活跃的状态。这样不仅会损耗大量的CPU资源，还会影响目标runLoop处理其它事件源。
这里我们用另外一种方法来统计FPS的帧率：
主要思路:记录主线程runloop在kCFRunLoopAfterWaiting的时间戳，然后在kCFRunLoopBeforeWaiting的时候算出两者的时间差，如果时间差大于16.67ms，就用1000ms减去时间差，然后启动定时器，每隔1秒回调一次，这时候将剩下的时间除以一帧的时间16.67ms,算出帧数，进行回调。
A.辅助变量
/// 主线程 runloop 唤醒状态 时间
static u_int64_t _MainRunLoopAfterWaitingStatusTime = 0;
// 一秒钟 为 10000毫秒
static float _MainRunLoopMillisecondPerSecond = 1000.0;
// 每一帧 时间 回调为 16.67
static double _MainRunLoopBlanceMillisecondPerFrame = 16.666666;
B.实现思路
- 监听
主线程runloop的状态回调状态，同时在主线程开启一个dispatch_source_t的定时器，每1秒回调一次
- (void)startMonitor {
if (!_monitorRunLoop) {
CFRunLoopObserverContext context = { 0, nil, NULL, NULL };
CFRunLoopObserverRef observer = CFRunLoopObserverCreate(kCFAllocatorDefault,
kCFRunLoopAllActivities,
YES,
0,
&_MainRunLoopObserverCallBack,
&context);
CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
CFRelease(observer);
[self startFpsTimer];
[NSThread detachNewThreadSelector:@selector(monitorThreadStart) toTarget:self withObject:nil];
}
}
- 然后在
runloop处于kCFRunLoopAfterWaiting的时候，记录当前时间戳，在runloop处于kCFRunLoopBeforeWaiting的时候，算出两者时间差，如果时间差大于16.67毫秒，就用_MainRunLoopMillisecondPerSecond减去时间差，得出剩余时间.
static mach_timebase_info_data_t _MainRunLoopFrameTimeBase(void) {
static mach_timebase_info_data_t *timebase = 0;
if (!timebase) {
timebase = malloc(sizeof(mach_timebase_info_data_t));
mach_timebase_info(timebase);
}
return *timebase;
}
static void _MainRunLoopTimeDifference(){
mach_timebase_info_data_t timebase = _MainRunLoopFrameTimeBase();
u_int64_t check = mach_absolute_time();
u_int64_t sum = (check - _MainRunLoopAfterWaitingStatusTime) * (double)timebase.numer / (double)timebase.denom / 1e6;
_MainRunLoopAfterWaitingStatusTime = check;
if (sum > _MainRunLoopBlanceMillisecondPerFrame) {
NSInteger blanceFramePerSecond = (NSInteger)(_MainRunLoopMillisecondPerSecond - sum);
_MainRunLoopMillisecondPerSecond = (blanceFramePerSecond > 0) ? blanceFramePerSecond : 0;
NSLog(@"sum: %lld", sum);
NSLog(@"_MainRunLoopMillisecondPerSecond = %ld", (long)_MainRunLoopMillisecondPerSecond);
}
}
static void _MainRunLoopFrameCallBack(CFRunLoopActivity activity) {
if (activity == kCFRunLoopAfterWaiting){
_MainRunLoopAfterWaitingStatusTime = mach_absolute_time();
}
else {
_MainRunLoopTimeDifference();
}
}
static void _MainRunLoopObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) {
_MainRunLoopActivity = activity;
if (_MainRunLoopActivity == kCFRunLoopBeforeWaiting ||
_MainRunLoopActivity == kCFRunLoopAfterWaiting) {
_MainRunLoopFrameCallBack(activity);
}
}
- 在定时器
1秒的回调的时候，先去判断当前之间和之前记录时间戳差值是否大于16.67ms，如果大于，减去时间差值，然后将剩余时间转化为帧数，进行回调，然后将_MainRunLoopMillisecondPerSecond重置为1000ms.
- (void)startFpsTimer {
_gcdTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
dispatch_source_set_timer(_gcdTimer, DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC, 0.0 * NSEC_PER_SEC);
dispatch_source_set_event_handler(_gcdTimer, ^{
_MainRunLoopTimeDifference();
NSInteger fps = (NSInteger)(_MainRunLoopMillisecondPerSecond/_MainRunLoopBlanceMillisecondPerFrame);
if (self.fpsBlock) {
self.fpsBlock(fps);
}
_MainRunLoopMillisecondPerSecond = 1000.0;
});
dispatch_resume(_gcdTimer);
}
以上是主要的实现逻辑，具体详见:
最后
如果大家有什么疑问或者意见向左的地方，欢迎大家留言讨论。
