卡顿监测的核心是检测主线程是否被长时间阻塞，导致无法及时更新 UI。
卡顿的本质
帧率与刷新率
-
iOS 屏幕刷新率：60Hz（ProMotion 120Hz）
-
每帧理论时间：16.67ms（60Hz）或 8.33ms（120Hz）
-
卡顿定义：一帧画面渲染时间超过 16.67ms → 丢帧
VSync 信号
text
CPU/GPU 处理时间线：
[计算开始] → [提交渲染] → [VSync 信号] → [屏幕显示]
↓
如果这里 >16.67ms → 错过本次 VSync → 卡顿卡顿监测的三种核心方法
1. FPS 监测法
最基础的卡顿指标，但不够精确。
class FPSMonitor {
private var displayLink: CADisplayLink?
private var lastTimestamp: TimeInterval = 0
private var count: Int = 0
private var fps: Int = 0
func start() {
displayLink = CADisplayLink(target: self, selector: #selector(tick))
displayLink?.add(to: .main, forMode: .common)
}
@objc func tick(_ link: CADisplayLink) {
guard lastTimestamp > 0 else {
lastTimestamp = link.timestamp
return
}
count += 1
let interval = link.timestamp - lastTimestamp
if interval >= 1.0 {
fps = count
count = 0
lastTimestamp = link.timestamp
if fps < 55 { // 通常 55fps 为卡顿阈值
print("⚠️ 低帧率警告: \(fps) FPS")
}
}
}
}局限性：只能反映整体趋势，无法定位具体卡顿点。
2. 主线程 RunLoop 状态监测法（最常用）
核心原理：监控 RunLoop 每个循环的耗时。
RunLoop 工作原理
// RunLoop 的一次循环
while (1) {
// 1. 接收消息/事件 (Source0, Source1)
__CFRunLoopDoSources(runloop, mode, stopAfterHandle);
// 2. 处理定时器 (Timers)
__CFRunLoopDoTimers(runloop, mode);
// 3. UI 渲染 (渲染前)
__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(observer, kCFRunLoopBeforeTimers);
// 4. 处理 UI 更新 (Source0)
// 这里耗时过长就会卡顿！
// 5. 渲染提交 (渲染后)
__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(observer, kCFRunLoopBeforeWaiting);
// 6. 休眠，等待下一次唤醒
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer));
}监测实现
class RunLoopMonitor {
private var timeoutCount = 0
private var runLoopActivity: CFRunLoopActivity = .entry
private var dispatchSemaphore: DispatchSemaphore?
private var runLoopObserver: CFRunLoopObserver?
private var monitoring = false
// 卡顿阈值（秒）
private let threshold: TimeInterval = 0.05 // 50ms，超过即判定为卡顿
func start() {
guard !monitoring else { return }
monitoring = true
// 创建信号量，用于同步
dispatchSemaphore = DispatchSemaphore(value: 0)
// 创建 RunLoop 观察者
let observer = CFRunLoopObserverCreateWithHandler(
kCFAllocatorDefault,
CFRunLoopActivity.allActivities.rawValue,
true,
0
) { [weak self] (observer, activity) in
guard let self = self else { return }
// 记录当前 RunLoop 状态
self.runLoopActivity = activity
// 发送信号，唤醒监控线程
self.dispatchSemaphore?.signal()
}
runLoopObserver = observer
// 将观察者添加到主线程 RunLoop
CFRunLoopAddObserver(
CFRunLoopGetMain(),
observer,
CFRunLoopMode.commonModes
)
// 在子线程中监控超时
DispatchQueue.global().async { [weak self] in
self?.monitorRunLoop()
}
}
private func monitorRunLoop() {
guard let semaphore = dispatchSemaphore else { return }
while monitoring {
// 等待信号量，如果超时说明主线程卡住了
let result = semaphore.wait(timeout: .now() + threshold)
// 超时发生
if result == .timedOut {
// 排除正常运行的状态
if runLoopActivity == .beforeSources ||
runLoopActivity == .afterWaiting {
timeoutCount += 1
if timeoutCount < 2 {
continue // 忽略单次超时
}
// 连续超时，判定为卡顿
print("🚨 检测到卡顿！RunLoop 状态: \(runLoopActivity.rawValue)")
// 采集堆栈信息（关键！）
captureStackTrace()
}
} else {
timeoutCount = 0 // 正常执行，重置计数器
}
}
}
private func captureStackTrace() {
// 获取所有线程的堆栈
let symbols = Thread.callStackSymbols
// 过滤出主线程堆栈
DispatchQueue.main.async {
let mainThreadStack = Thread.callStackSymbols
print("主线程堆栈:\n\(mainThreadStack.joined(separator: "\n"))")
// 这里可以上报到监控系统
self.reportStutter(stackTrace: mainThreadStack)
}
}
func stop() {
monitoring = false
dispatchSemaphore = nil
if let observer = runLoopObserver {
CFRunLoopRemoveObserver(
CFRunLoopGetMain(),
observer,
CFRunLoopMode.commonModes
)
runLoopObserver = nil
}
}
}3. 子线程 Ping 方法
原理：子线程定期"ping"主线程，检查是否及时响应。
class PingMonitor {
private var pingThread: Thread?
private var isMonitoring = false
private let pingInterval: TimeInterval = 0.05 // 50ms
private let timeoutThreshold: TimeInterval = 0.1 // 100ms
func start() {
isMonitoring = true
pingThread = Thread { [weak self] in
while self?.isMonitoring == true {
let startTime = Date()
// 向主线程发送任务
DispatchQueue.main.async {
self?.mainThreadResponded(at: startTime)
}
// 等待响应
Thread.sleep(forTimeInterval: self?.timeoutThreshold ?? 0.1)
// 检查是否超时
if let lastResponse = self?.lastResponseTime,
Date().timeIntervalSince(lastResponse) > self?.timeoutThreshold ?? 0.1 {
print("⚠️ 主线程响应超时")
self?.captureStackTrace()
}
Thread.sleep(forTimeInterval: self?.pingInterval ?? 0.05)
}
}
pingThread?.start()
}
private var lastResponseTime = Date()
private func mainThreadResponded(at time: Date) {
lastResponseTime = Date()
// 正常响应
}
}卡顿根因分析
常见卡顿原因
// 1. 主线程同步网络请求 ❌
let data = try? Data(contentsOf: url) // 阻塞主线程
// 2. 复杂/大量的 UI 布局计算
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) {
// 复杂的 cell 布局计算
performComplexLayout() // 耗时 > 16ms
}
// 3. 大量文件/数据库操作
func saveLargeData() {
let data = Array(repeating: "data", count: 100000)
UserDefaults.standard.set(data, forKey: "large") // 序列化耗时
}
// 4. 死锁/竞争条件
DispatchQueue.main.sync { // 在主线程上同步执行 -> 死锁风险
updateUI()
}
// 5. 过度绘制/离屏渲染
view.layer.cornerRadius = 10
view.layer.masksToBounds = true // 触发离屏渲染卡顿监控 SDK 设计
完整监控方案架构
class PerformanceMonitor {
// 多个监控维度
private let fpsMonitor = FPSMonitor()
private let runLoopMonitor = RunLoopMonitor()
private let memoryMonitor = MemoryMonitor()
private let cpuMonitor = CPUMonitor()
// 配置
struct Config {
var fpsThreshold: Int = 55
var stutterThreshold: TimeInterval = 0.05 // 50ms
var sampleRate: Float = 0.1 // 10%采样率
var enableStackTrace: Bool = true
}
func start(config: Config = Config()) {
// 开始各项监控
fpsMonitor.start(threshold: config.fpsThreshold)
runLoopMonitor.start(threshold: config.stutterThreshold)
// 设置采样率
if Float.random(in: 0...1) < config.sampleRate {
memoryMonitor.start()
cpuMonitor.start()
}
}
func reportStutter(stackTrace: [String]) {
// 1. 本地记录
saveToLocalCache(stackTrace)
// 2. 聚合上报（避免频繁上报）
aggregateAndReport()
// 3. 实时预警（可选）
if shouldAlert() {
showDeveloperWarning()
}
}
}卡顿堆栈分析技巧
符号化与过滤
func analyzeStackTrace(_ stack: [String]) {
// 1. 过滤系统调用
let userFrames = stack.filter { !$0.contains("UIKitCore") &&
!$0.contains("libsystem") }
// 2. 提取关键函数
let keyFunctions = userFrames.compactMap { frame -> String? in
// 解析堆栈帧，提取函数名
let pattern = "\\s+\\d+\\s+(\\S+)\\s+(0x[0-9a-f]+)\\s+(.+)$"
if let regex = try? NSRegularExpression(pattern: pattern),
let match = regex.firstMatch(in: frame, range: NSRange(frame.startIndex..., in: frame)),
let range = Range(match.range(at: 3), in: frame) {
return String(frame[range])
}
return nil
}
// 3. 识别卡顿模式
analyzePattern(keyFunctions)
}
func analyzePattern(_ functions: [String]) {
// 常见卡顿模式识别
if functions.contains(where: { $0.contains("tableView:cellForRowAt:") }) {
print("🔍 卡顿原因：复杂 Cell 布局")
} else if functions.contains(where: { $0.contains("imageWithData:") }) {
print("🔍 卡顿原因：大图解码")
} else if functions.contains(where: { $0.contains("JSONSerialization.jsonObject") }) {
print("🔍 卡顿原因：JSON 解析")
}
}优化建议
监控优化
-
采样率控制：生产环境使用低采样率（如 1%）
-
聚合上报：相同堆栈合并，避免数据爆炸
-
智能熔断：频繁相同卡顿降低监控频率
性能优化
// ✅ 优化示例
class OptimizedCell: UITableViewCell {
// 1. 异步图片加载
func loadImageAsync(url: URL) {
DispatchQueue.global().async {
let data = try? Data(contentsOf: url)
DispatchQueue.main.async {
self.imageView?.image = UIImage(data: data)
}
}
}
// 2. 缓存复杂计算结果
private var cachedHeight: CGFloat?
func cellHeight() -> CGFloat {
if let height = cachedHeight { return height }
let height = calculateComplexHeight()
cachedHeight = height
return height
}
// 3. 离屏渲染优化
func optimizeLayer() {
layer.cornerRadius = 10
layer.masksToBounds = true
layer.shouldRasterize = true // 开启光栅化
layer.rasterizationScale = UIScreen.main.scale
}
}监控数据可视化
卡顿热力图
struct StutterReport {
let timestamp: Date
let duration: TimeInterval
let stackTrace: [String]
let deviceInfo: String
let pageName: String
// 转换为可上报格式
func toDictionary() -> [String: Any] {
return [
"type": "stutter",
"duration": duration,
"page": pageName,
"device": deviceInfo,
"stack": stackTrace.prefix(10).joined(separator: "\n"),
"timestamp": timestamp.timeIntervalSince1970
]
}
}总结
| 监测方法 | 精度 | 开销 | 适用场景 |
|---|---|---|---|
| FPS 监测 | 低 | 低 | 整体趋势监控 |
| RunLoop 监测 | 高 | 中 | 精确卡顿定位 |
| Ping 方法 | 中 | 高 | 简单响应测试 |
最佳实践：
-
开发阶段：使用 RunLoop 监测 + 完整堆栈
-
测试阶段：结合自动化测试 + 性能 profiling
-
生产环境：采样监控 + 智能聚合上报
卡顿监测不是目的，优化用户体验才是根本。监测数据需要配合代码优化、架构改进才能真正提升 App 性能。