iOS 卡顿

4、解决方案

4.1 CPU 方面

4.1.1 尽量使用轻量级对象，比如用不到时间处理的地方，可以考虑用 CALayer替代UIView

4.1.2 不要频繁调用 UIView的相关属性，例如 ： frame、bounds、transform等属性，减少不必要的修改
提前计算好布局，在有需要的时候一次性调整对应属性，不要多次修改属性

4.1.3 AutoLayout会比直接设置 frame消耗更多的CPU资源

4.1.4 图片的 size最好刚好跟 UIImageView的size保持一直

4.1.5 控制好线程的最大并发量

4.1.5 尽量把耗时操作放到子线程,例如: 文本计算、图片解码、绘制

4.2 GPU 方面

4.2.1 尽量减少视图数量和层次

4.2.2 GPU 能处理的最大纹理的尺寸为 4096*4096,一旦超过这个尺寸，就会占用 CPU资源进行处理，所以纹理尽量不要超过这个尺寸

4.2.3 减少透明的视图，不透明就设置 opaque为 YES

4.2.3 尽量避免出现离屏渲染

三、离屏渲染

1、什么是离屏渲染
在 OpenGL中, GPU有两种渲染方式
当前屏幕渲染(On-Screen Rendering)：在当前用于显示的屏幕缓冲区进行渲染操作
离屏渲染(off-Screen Rendering):在当前屏幕缓冲区以外新开辟一个缓冲区进行渲染操作

2、离屏渲染消耗性能
需要开辟新的缓冲区(buffer)
离屏渲染的整个过程，需要多次切换上下文，显示从当前屏幕(on-Screen)切换到离屏(off-Screen),等到离屏渲染结束后，将离屏缓冲区的渲染结果显示到屏幕上后，又需要将上下文从从屏切换到当前屏幕。

3、如何触发离屏渲染

光珊化(layer.shouldRasterize = YES)

遮罩(layer.mask)

圆角，同时设置 layer.maskToBounds = YES; layer.cornerRadius > 0，如果非得设置，可以用 CoreGraphics绘制圆角会用中间挖空的带圆角的图片。

阴影，例如: layer.shadowColor, 可通过 shadowPath设置阴影

4、如何检测离屏渲染

点击模拟器，在其菜单栏 点击 Debug，在其下拉菜单栏选择 Color off-Screen Rendered
如果，存在离屏熏染，对应突然会被高亮成黄色。

四、卡顿检测
平时所说的 "卡顿"主要是因为在主线程执行了比较耗时的操作，那么如何监听哪些操作比较耗时呢？可以添加 Observe到主线程的 RunLoop中，通过监听 RunLoop状态切换的耗时，达到监控卡顿的目的。即结束休眠到处理 souce0这一过程所消耗的时间。
推荐LXDAppFluecyMonitor
核心代码如下：

#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);
    CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
    
    dispatch_async(lxd_event_monitor_queue(), ^{
        while (SHAREDMONITOR.isMonitoring) {
            if (SHAREDMONITOR.currentActivity == kCFRunLoopBeforeWaiting) {
                __block BOOL timeOut = YES;
                dispatch_async(dispatch_get_main_queue(), ^{
                    timeOut = NO;
                    dispatch_semaphore_signal(SHAREDMONITOR.eventSemphore);
                });
                [NSThread sleepForTimeInterval: lxd_time_out_interval];
                if (timeOut) {
                    [LXDBacktraceLogger lxd_logMain];
                }
                dispatch_wait(SHAREDMONITOR.eventSemphore, DISPATCH_TIME_FOREVER);
            }
        }
    });
    
    dispatch_async(lxd_fluecy_monitor_queue(), ^{
        while (SHAREDMONITOR.isMonitoring) {
            long waitTime = dispatch_semaphore_wait(self.semphore, dispatch_time(DISPATCH_TIME_NOW, lxd_wait_interval));
            if (waitTime != LXD_SEMPHORE_SUCCESS) {
                if (!SHAREDMONITOR.observer) {
                    SHAREDMONITOR.timeOut = 0;
                    [SHAREDMONITOR stopMonitoring];
                    continue;
                }
                if (SHAREDMONITOR.currentActivity == kCFRunLoopBeforeSources || SHAREDMONITOR.currentActivity == kCFRunLoopAfterWaiting) {
                    if (++SHAREDMONITOR.timeOut < 5) {
                        continue;
                    }
                    [LXDBacktraceLogger lxd_logMain];
                    [NSThread sleepForTimeInterval: lxd_restore_interval];
                }
            }
            SHAREDMONITOR.timeOut = 0;
        }
    });
}