现在对于app的要求越来越高，并不是像以前我们只要把功能需求做出来就行。还要求我们对app做各种优化，写出高质量的代码。所以对于界面的流畅度的监测就非常有必要了。那应该如何监测呢？
FPS的监测
- 原理：CADisplayLink是一个特殊的定时器，它的调用执行和GPU的渲染有关，我们常常说的60刷和120hz刷屏。也就以为这，默认情况下CADisplayLink每秒会调用60次或者120次。我们就可以计算它在一秒内调用了多少次，来看界面的流畅度。正常情况下50<fps 肉眼看不出来卡顿，55以上就很流畅，说明你已经做的很好了。下面我们来看代码，具体是如何实现的。
//初始化创建
CADisplayLink *link=[CADisplayLink displayLinkWithTarget:self selector:@selector(displayAction:)];
//添加到主线程中去
[link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
//通记录回调次数和相隔时间 计算fps
-(void)displayAction:(CADisplayLink *)link{
//记录上次的时间
static NSTimeInterval lastTime = 0;
//记录回调了多少次
static NSInteger frameCount = 0;
if (lastTime==0) {
lastTime=link.timestamp;
return;
}
frameCount++;
NSTimeInterval duration=link.timestamp-lastTime;
//刷新间隔1秒
if (duration>=1) {
NSInteger fps=frameCount/duration;
frameCount=0;
lastTime=link.timestamp;
}
}
- 优缺点：通过上面的代码，可以看到界面帧率。越小说明界面越不流畅。但它的作用也仅仅只是这样了。即使知道了卡顿，我们还要自己去查找，无法快速的定位到底是那个方法引起的卡顿。
RunLoop监听应用程序卡顿
在前面我们讲过runloop那个非常烂大街的流程图，这里就不放了。
KCFRunLoopEntyr开始runloop-->timer--> kCFRunLoopBeforeSources(开始处理事件)-->kCFRunLoopBeforeWaiting(事件处理完了，开始休眠)--> kCFRunLoopAfterWaiting（被叫醒）-->然后开始回到最开的步骤 重新实现流程
原理：创建一个子线程进行循环监测，每次检测时设置为YES，然后派发任务切换到主线程，将标记位置设置为NO，如果没有设置成NO，说明主线程卡顿了。关键代码如下：
#import <Foundation/Foundation.h>
#define SHAREDMONITOR [LXDAppFluecyMonitor sharedMonitor]
/*!
* @brief 监听UI线程卡顿
*/
@interface LXDAppFluecyMonitor : NSObject
+ (instancetype)sharedMonitor;
- (void)startMonitoring;
- (void)stopMonitoring;
@end
#import "LXDAppFluecyMonitor.h"
#define LXD_DEPRECATED_POLLUTE_MAIN_QUEUE
@interface LXDAppFluecyMonitor ()
@property (nonatomic, assign) int timeOut;
@property (nonatomic, assign) BOOL isMonitoring;
@property (nonatomic, assign) CFRunLoopObserverRef observer;
@property (nonatomic, assign) CFRunLoopActivity currentActivity;
@property (nonatomic, strong) dispatch_semaphore_t semphore;
@property (nonatomic, strong) dispatch_semaphore_t eventSemphore;
@end
#define LXD_SEMPHORE_SUCCESS 0
static NSTimeInterval lxd_restore_interval = 5;
static NSTimeInterval lxd_time_out_interval = 1;
static int64_t lxd_wait_interval = 200 * NSEC_PER_MSEC;
/*!
* @brief 监听runloop状态在after waiting和before sources之间
*/
static inline dispatch_queue_t lxd_fluecy_monitor_queue() {
static dispatch_queue_t lxd_fluecy_monitor_queue;
static dispatch_once_t once;
dispatch_once(&once, ^{
lxd_fluecy_monitor_queue = dispatch_queue_create("com.sindrilin.lxd_monitor_queue", NULL);
});
return lxd_fluecy_monitor_queue;
}
#define LOG_RUNLOOP_ACTIVITY 0
static void lxdRunLoopObserverCallback(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void * info) {
SHAREDMONITOR.currentActivity = activity;
dispatch_semaphore_signal(SHAREDMONITOR.semphore);
#if LOG_RUNLOOP_ACTIVITY
switch (activity) {
case kCFRunLoopEntry:
NSLog(@"runloop entry");
break;
case kCFRunLoopExit:
NSLog(@"runloop exit");
break;
case kCFRunLoopAfterWaiting:
NSLog(@"runloop after waiting");
break;
case kCFRunLoopBeforeTimers:
NSLog(@"runloop before timers");
break;
case kCFRunLoopBeforeSources:
NSLog(@"runloop before sources");
break;
case kCFRunLoopBeforeWaiting:
NSLog(@"runloop before waiting");
break;
default:
break;
}
#endif
};
@implementation LXDAppFluecyMonitor
#pragma mark - Singleton override
+ (instancetype)sharedMonitor {
static LXDAppFluecyMonitor * sharedMonitor;
static dispatch_once_t once;
dispatch_once(&once, ^{
sharedMonitor = [[super allocWithZone: NSDefaultMallocZone()] init];
[sharedMonitor commonInit];
});
return sharedMonitor;
}
+ (instancetype)allocWithZone: (struct _NSZone *)zone {
return [self sharedMonitor];
}
- (void)dealloc {
[self stopMonitoring];
}
- (void)commonInit {
self.semphore = dispatch_semaphore_create(0);
}
#pragma mark - Public
- (void)startMonitoring {
if (_isMonitoring) { return; }
_isMonitoring = YES;
CFRunLoopObserverContext context = {
0,
(__bridge void *)self,
NULL,
NULL
};
//创建监听者
_observer = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, &lxdRunLoopObserverCallback, &context);
//监听主RunLoop
CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
dispatch_async(lxd_event_monitor_queue(), ^{
NSLog(@"%@",[NSThread currentThread]);
while (SHAREDMONITOR.isMonitoring) {
//主线程的RunLoop 即将进入休眠
if (SHAREDMONITOR.currentActivity == kCFRunLoopBeforeWaiting) {
//默认超时
__block BOOL timeOut = YES;
NSLog(@"0");
dispatch_async(dispatch_get_main_queue(), ^{
//切换到主线程 执行任务
//若主线程没有出现卡顿 能正常执行任务 将timeOut设置为NO
//若主线程出现卡顿 不能能正常执行任务
timeOut = NO;
//发送信号量 +1
dispatch_semaphore_signal(SHAREDMONITOR.eventSemphore);
NSLog(@"1");
});
NSLog(@"2");
//当前子线程休眠1秒钟
[NSThread sleepForTimeInterval: lxd_time_out_interval];
NSLog(@"3");
//超时打印函数调用栈
if (timeOut) {
NSLog(@"4");
[LXDBacktraceLogger lxd_logMain];
}
NSLog(@"5");
//释放信号量 -1 此时的信号量为-1<0 下面的逻辑不会执行 循环依然执行
dispatch_wait(SHAREDMONITOR.eventSemphore, DISPATCH_TIME_FOREVER);
NSLog(@"6");
}
}
});
}
- (void)stopMonitoring {
if (!_isMonitoring) { return; }
_isMonitoring = NO;
CFRunLoopRemoveObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
CFRelease(_observer);
_observer = nil;
}
@end
上面一堆的代码，主要实现的逻辑方法在startMonitoring中
- 1、首先判断_isMonitoring，当_isMonitoring为YES时，说明主线程一直处于卡顿状态。
- 2、_isMonitoring为NO时，表示已派发任务到主线程。这时我们把_isMonitoring设置为YES。
-3、 创建监听这，监听主runloop。 - 4、创建子线程lxd_fluecy_monitor_queue。while判断_isMonitoring，为0,表示在指定时间内接收到主线程发出的信号；非0，表示在指定时间内没有接收到主线程发出的信号，主线程可能在执行耗时任务，有可能造成应用程序的卡顿
-5、判断主runloop即将进入休眠，这时候切换到主线程 执行任务。同时我们让当前的子线程休眠一秒。这里为什么要休眠呢？这时因为，切换到主线程 设置timeout为NO，如果在我们设置的时间内能切换成功，就判断他不卡顿。如若1秒以后timeout还是yes，证明主线程在执行耗时操作。没有办法去执行 timeOut = NO;。这个时候我们就要记录卡顿的日志[LXDBacktraceLogger lxd_logMain];
-6.最后 信号量也没办法释放，他会一直等待主线程切换执行，发出信号成功以后才能释放。
使用Instrument工具实时监测App
使用Time Profiler
修改项目为debug模式，然后如下图设置
截屏2022-01-25 下午4.18.57.png
按步骤打开product-->profile-->time
截屏2022-01-25 下午4.24.13.png
设置call tree，显示代码位置。
以上就完成了界面卡顿监测。
网友评论