如何用RunLoop检测iOS App 卡顿

首先本文的思路来自于网上的各类资料。而后搜了半天发现没有swift版的，因而撸了一个。

其实具体的思路很是的简单:

1. 首先建立一个runloop的observer对象:

   let info = Unmanaged<Monitor>.passUnretained(self).toOpaque()
    var context: CFRunLoopObserverContext = CFRunLoopObserverContext(version: 0, info: info, retain: nil, release: nil, copyDescription: nil)
    self.runLoopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault, CFRunLoopActivity.allActivities.rawValue, true, 0, runLoopCallBack(), &context)
   复制代码

2. 而后将这个观察对象添加到runloop的common modes中

   CFRunLoopAddObserver(CFRunLoopGetCurrent(), self.runLoopObserver, CFRunLoopMode.commonModes)
   复制代码

   ps: 由于common modes是会一直存在于runloop中的，不会被中断，因此讲检测的observer对象放到这个modes里去。

3. 检测CFRunLoopActivity

   CFRunLoopActivity这个结构有很是多的状态吧，咱们须要判断的是:

   beforeSources: 进入睡眠前
    afterWaiting: 唤醒后的状态
   复制代码

   若是runloop返回的activity的值是上述的两个，那么就能够认为出现了卡顿的现象

4. 这里用了dispatch的信号机制

   self.dispatchSemaphore?.wait(timeout: DispatchTime.now() + 1 / 50)

   这段代码认定，若是每秒的帧数少于50，那么就认为发生了卡顿的现象

实现的逻辑就是这么四步，下面贴上所有的代码:

import Foundation

class Monitor {
  
  static let shared = Monitor()
  
  private var runLoopObserver: CFRunLoopObserver?
  private var dispatchSemaphore: DispatchSemaphore?
  private var runLoopActivity: CFRunLoopActivity?
  
  init() {}
  
  func beginMonitor() {
    guard self.runLoopObserver == nil else { return }
    
    self.dispatchSemaphore = DispatchSemaphore(value: 0)

    let info = Unmanaged<Monitor>.passUnretained(self).toOpaque()
    var context: CFRunLoopObserverContext = CFRunLoopObserverContext(version: 0, info: info, retain: nil, release: nil, copyDescription: nil)
    self.runLoopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault, CFRunLoopActivity.allActivities.rawValue, true, 0, runLoopCallBack(), &context)
    
    CFRunLoopAddObserver(CFRunLoopGetCurrent(), self.runLoopObserver, CFRunLoopMode.commonModes)
    
    DispatchQueue.global().async {
      // 若是少于50每帧, 则认为卡顿
      while true {
        guard let sem = self.dispatchSemaphore?.wait(timeout: DispatchTime.now() + 1 / 50) else { return }
        if case DispatchTimeoutResult.timedOut = sem {
          guard let _ = self.runLoopObserver else {
            self.dispatchSemaphore = nil
            self.runLoopActivity = nil
            return
          }
          
          // beforeSources: 进入睡眠前
          // afterWaiting: 唤醒后的状态
          if (self.runLoopActivity == CFRunLoopActivity.beforeSources || self.runLoopActivity == CFRunLoopActivity.afterWaiting) {
            print("symbo: \(Thread.callStackSymbols)")
            print("打印卡顿堆栈...")
          }
        }
      }
    }
  }
  
  func endMonitor() {
    if self.runLoopObserver != nil {
      return
    }
    
    CFRunLoopRemoveObserver(CFRunLoopGetCurrent(), self.runLoopObserver, CFRunLoopMode.commonModes)
    self.runLoopObserver = nil
  }
  
}

extension Monitor {
  func runLoopCallBack() -> CFRunLoopObserverCallBack {
    return { (observer, activity, context) -> Void in
      let weakSelf = Unmanaged<Monitor>.fromOpaque(context!).takeUnretainedValue()
      weakSelf.runLoopActivity = activity
      weakSelf.dispatchSemaphore?.signal()
    }
  }
}复制代码