当前位置： 首页 > news >正文

iOS RunLoop 深入解析

news 来源：原创 2025/5/1 6:27:29

本文深入探讨 iOS 中 RunLoop 的实现原理、工作机制以及实际应用。通过源码分析和实际案例，帮助读者全面理解 RunLoop 在 iOS 系统中的重要作用。

一、RunLoop 基础概念

1. RunLoop 的定义与作用

RunLoop 是 iOS 系统中用于处理事件和消息的循环机制。它负责管理线程的事件处理、消息传递和任务调度，是 iOS 应用能够持续运行并响应用户交互的基础。

主要功能：

  • 保持程序持续运行
  • 处理各种事件（触摸事件、定时器事件、网络事件等）
  • 节省 CPU 资源，提高程序性能
  • 协调线程间的通信

2. RunLoop与线程的关系

  • 每个线程都有且只有一个对应的 RunLoop
  • 主线程的 RunLoop 默认是开启的
  • 子线程的 RunLoop 默认是关闭的，需要手动开启
  • RunLoop 与线程是一一对应的关系
  • RunLoop 的生命周期与线程的生命周期一致

二、RunLoop 的核心组件与底层实现

1. 核心组件及其底层结构

1.1 核心组件层级结构

CFRunLoopRef
├── CFRunLoopModeRef (多个)
│   ├── CFRunLoopSourceRef (Source0)
│   ├── CFRunLoopSourceRef (Source1)
│   ├── CFRunLoopTimerRef
│   └── CFRunLoopObserverRef
├── CFRunLoopCommonModes
└── CFRunLoopCommonModeItems

RunLoop 的核心组件形成了一个完整的层级结构，从顶层到底层依次为：

  1. CFRunLoopRef：RunLoop 的核心，负责管理整个 RunLoop 的生命周期、状态和所有子组件。

  2. CFRunLoopModeRef：RunLoop 的运行模式，用于隔离不同场景下的事件处理，每个 Mode 包含独立的事件源集合。

  3. CFRunLoopSourceRef：RunLoop 的事件源，分为处理应用内部事件的 Source0 和处理系统事件的 Source1。

  4. CFRunLoopTimerRef：RunLoop 的定时器，用于在特定时间点触发事件，支持重复触发和单次触发。

  5. CFRunLoopObserverRef：RunLoop 的观察者，用于监听 RunLoop 的状态变化，支持监控整个生命周期。

1.2 CFRunLoopRef

CFRunLoopRef 是 RunLoop 的核心对象，它包含了 RunLoop 的所有状态和配置信息。在 Core Foundation 中，RunLoop 是一个 C 语言结构体，通过 CFRunLoopRef 进行引用。

底层结构：

struct __CFRunLoop {CFRuntimeBase _base;           // 基础运行时信息pthread_mutex_t _lock;         // 互斥锁，保证线程安全CFStringRef _currentMode;      // 当前运行模式CFMutableSetRef _modes;        // 所有模式集合CFMutableSetRef _commonModes;  // 通用模式集合CFMutableSetRef _commonModeItems; // 通用模式项集合CFRunLoopModeRef _currentMode; // 当前模式引用CFMutableSetRef _sources0;     // Source0 集合，处理应用内部事件CFMutableSetRef _sources1;     // Source1 集合，处理系统事件CFMutableArrayRef _observers;  // 观察者数组，监听 RunLoop 状态变化CFMutableArrayRef _timers;     // 定时器数组，管理定时任务
};

1.3 CFRunLoopMode

CFRunLoopMode 定义了 RunLoop 的运行模式，每个 RunLoop 可以包含多个 Mode，但同一时间只能运行在一个 Mode 下。Mode 的主要作用是隔离不同场景下的事件处理。

底层结构：

struct __CFRunLoopMode {CFRuntimeBase _base;CFStringRef _name;            // 模式名称CFMutableSetRef _sources0;    // Source0 集合CFMutableSetRef _sources1;    // Source1 集合CFMutableArrayRef _observers; // 观察者数组CFMutableArrayRef _timers;    // 定时器数组
};

常见模式：

  • NSDefaultRunLoopMode: App 的默认运行模式，处理大多数输入源和定时器
  • UITrackingRunLoopMode: 界面跟踪模式，用于 ScrollView 滑动时的模式，保证滑动时不受其他模式的影响，保证滑动的流畅性，优先级较高
  • NSRunLoopCommonModes: 这是一个组合模式，包含了 Default Mode 和 Tracking Mode，不是一个真正的模式，而是一个模式的集合，添加到这个模式的事件源，会同时运行在 Default 和 Tracking 模式下
  • GSEventReceiveRunLoopMode: 接收系统事件的内部 Mode，通常用不到
  • kCFRunLoopCommonModes: Core Foundation 中的通用模式，与 NSRunLoopCommonModes 对应

1.4 CFRunLoopSource

CFRunLoopSource 是 RunLoop 的事件源，分为两种类型：

  1. Source0：处理应用内部事件

    • 需要手动标记为待处理
    • 包含一个回调函数，当事件被触发时调用
    • 主要用于处理应用内部事件，如触摸事件、手势事件等

  2. Source1：处理系统事件

    • 基于 Mach Port 的，由系统内核触发
    • 包含一个 Mach Port 和一个回调函数
    • 主要用于处理系统事件，如网络事件、硬件事件等

底层结构：

struct __CFRunLoopSource {CFRuntimeBase _base;uint32_t _bits;              // 标志位，用于标识 Source 的类型和状态pthread_mutex_t _lock;       // 互斥锁，保证线程安全CFIndex _order;              // 优先级顺序，决定处理顺序CFMutableBagRef _runLoops;   // 关联的 RunLoop 集合union {CFRunLoopSourceContext version0;  // Source0 上下文CFRunLoopSourceContext1 version1; // Source1 上下文} _context;
};

1.5 CFRunLoopTimer

CFRunLoopTimer 是基于时间的触发器，用于在特定时间点触发事件。NSTimer 就是基于 RunLoop 的 Timer 实现的。

底层结构：

struct __CFRunLoopTimer {CFRuntimeBase _base;uint16_t _bits;              // 标志位，用于标识 Timer 的状态pthread_mutex_t _lock;       // 互斥锁，保证线程安全CFRunLoopRef _runLoop;       // 关联的 RunLoopCFMutableSetRef _rlModes;    // 运行模式集合CFAbsoluteTime _nextFireDate; // 下次触发时间CFTimeInterval _interval;    // 时间间隔CFTimeInterval _tolerance;   // 时间容差，允许的误差范围uint64_t _fireTSR;          // 触发时间戳CFIndex _order;             // 优先级顺序CFRunLoopTimerCallBack _callout; // 回调函数CFRunLoopTimerContext _context;  // 上下文信息
};

1.6 CFRunLoopObserver

CFRunLoopObserver 用于观察 RunLoop 的状态变化，可以监听 RunLoop 的整个生命周期。

底层结构：

struct __CFRunLoopObserver {CFRuntimeBase _base;pthread_mutex_t _lock;       // 互斥锁，保证线程安全CFRunLoopRef _runLoop;       // 关联的 RunLoopCFIndex _rlCount;           // RunLoop 计数CFOptionFlags _activities;  // 观察的活动CFIndex _order;            // 优先级顺序CFRunLoopObserverCallBack _callout; // 回调函数CFRunLoopObserverContext _context;  // 上下文信息
};

可监听的事件：

  • kCFRunLoopEntry：进入 RunLoop
  • kCFRunLoopBeforeTimers：即将处理 Timer
  • kCFRunLoopBeforeSources：即将处理 Source
  • kCFRunLoopBeforeWaiting：即将进入休眠
  • kCFRunLoopAfterWaiting：从休眠中唤醒
  • kCFRunLoopExit：退出 RunLoop

2. RunLoop 的启动流程

RunLoop 的运行流程是一个循环过程，主要包含以下步骤：

  1. 通知 Observer：即将进入 RunLoop
  2. 通知 Observer：即将处理 Timer
  3. 通知 Observer：即将处理 Source
  4. 处理 Source0（UI 事件、手动触发的 Source0）
  5. 检查是否有待处理的唤醒事件（Source1、Timer 或其他）
    ├─ 有 → 跳转到步骤 9（标记唤醒，无需休眠）
    └─ 无 → 继续
  6. 通知 Observer：即将进入休眠
  7. 进入休眠（等待 Mach Port 消息）
  8. 通知 Observer：从休眠中唤醒
  9. 处理唤醒时收到的消息
    ├─ GCD 主队列任务（最高优先级）
    ├─ 手动唤醒信号（CFRunLoopWakeUp）
    ├─ Source1 事件（触摸/硬件事件）
    └─ Timer 事件（到期的定时器）
  10. 回到步骤 2，继续循环

三、RunLoop 的实际应用

1. 性能优化

1.1 卡顿监控

通过 RunLoop Observer 可以监控主线程的卡顿情况，这是一个非常实用的性能监控工具。以下是一个完整的卡顿监控实现：

class RunLoopMonitor {private var observer: CFRunLoopObserver?private var lastActivity: CFRunLoopActivity = .entryprivate var lastTime: TimeInterval = 0private let semaphore = DispatchSemaphore(value: 0)func startMonitor() {// 创建观察者var context = CFRunLoopObserverContext(version: 0,info: Unmanaged.passUnretained(self).toOpaque(),retain: nil,release: nil,copyDescription: nil)observer = CFRunLoopObserverCreate(kCFAllocatorDefault,CFRunLoopActivity.allActivities.rawValue,true,0,runLoopObserverCallBack,&context)// 将观察者添加到主线程的 RunLoopCFRunLoopAddObserver(CFRunLoopGetMain(), observer, .commonModes)// 在子线程中监控卡顿DispatchQueue.global().async { [weak self] inguard let self = self else { return }while true {// 等待 50mslet semaphoreWait = self.semaphore.wait(timeout: .now() + 0.05)if semaphoreWait == .timedOut { // 超时if self.lastActivity == .beforeSources || self.lastActivity == .afterWaiting {// 检测到卡顿，记录堆栈信息self.logStackInfo()}}}}}private let runLoopObserverCallBack: CFRunLoopObserverCallBack = { (observer, activity, info) inguard let info = info else { return }let monitor = Unmanaged<RunLoopMonitor>.fromOpaque(info).takeUnretainedValue()monitor.lastActivity = activitymonitor.lastTime = Date().timeIntervalSince1970monitor.semaphore.signal()}private func logStackInfo() {// 获取当前线程的堆栈信息let callStackSymbols = Thread.callStackSymbolsprint("卡顿堆栈信息：\(callStackSymbols)")}
}

这段代码实现了一个完整的卡顿监控系统：

  1. 通过 RunLoop Observer 监听主线程 RunLoop 的状态变化
  2. 使用信号量机制检测 RunLoop 是否卡顿
  3. 当检测到卡顿时，记录当前的堆栈信息
  4. 可以设置卡顿阈值（当前设置为 50ms）

1.2 性能优化技巧

1.2.1 合理使用 RunLoop Mode
class ScrollViewOptimizer: NSObject, UIScrollViewDelegate {func scrollViewDidScroll(_ scrollView: UIScrollView) {// 在滚动时暂停某些操作perform(#selector(heavyOperation),with: nil,afterDelay: 0,inModes: [.default])}func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {// 在滚动结束后恢复操作perform(#selector(heavyOperation),with: nil,afterDelay: 0,inModes: [.common])}@objc private func heavyOperation() {// 耗时操作}
}

这段代码展示了如何利用 RunLoop Mode 来优化滚动性能：

  1. 在滚动时，将耗时操作限制在 Default Mode
  2. 在滚动结束后，将操作添加到 Common Modes
  3. 这样可以避免滚动时的性能问题
1.2.2 优化定时器
class TimerOptimizer {private var timer: Timer?private let tolerance: TimeInterval = 0.1 // 100ms 的容差func setupOptimizedTimer() {// 创建定时器timer = Timer(timeInterval: 1.0,target: self,selector: #selector(timerAction),userInfo: nil,repeats: true)// 设置时间容差，提高性能timer?.tolerance = tolerance// 添加到 RunLoopRunLoop.current.add(timer!, forMode: .common)}@objc private func timerAction() {// 执行定时任务print("Timer fired at: \(Date())")}
}

这段代码展示了如何优化定时器的使用：

  1. 设置合理的时间容差，减少系统唤醒次数
  2. 使用 Common Modes 确保定时器在滚动时也能正常工作
  3. 避免在主线程执行耗时操作

2. 常见应用场景

2.1 常驻线程

class BackgroundWorker {private var workerThread: Thread?private var shouldKeepRunning = falsefunc start() {shouldKeepRunning = trueworkerThread = Thread(target: self, selector: #selector(workerThreadEntry), object: nil)workerThread?.start()}@objc private func workerThreadEntry() {autoreleasepool {// 获取当前线程的 RunLooplet runLoop = RunLoop.current// 添加 Port 防止 RunLoop 退出let port = Port()runLoop.add(port, forMode: .default)// 添加观察者监控 RunLoop 状态let observer = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault,CFRunLoopActivity.allActivities.rawValue,true,0) { (observer, activity) inswitch activity {case .entry:print("RunLoop 进入")case .exit:print("RunLoop 退出")default:break}}CFRunLoopAddObserver(CFRunLoopGetCurrent(), observer, .defaultMode)// 运行 RunLoopwhile shouldKeepRunning {runLoop.run(mode: .default, before: .distantFuture)}}}func stop() {shouldKeepRunning = falseperform(#selector(stopThread),on: workerThread!,with: nil,waitUntilDone: false)}@objc private func stopThread() {CFRunLoopStop(CFRunLoopGetCurrent())}
}

这段代码实现了一个完整的常驻线程：

  1. 创建并启动工作线程
  2. 在工作线程中设置 RunLoop
  3. 添加 Port 防止 RunLoop 退出
  4. 添加观察者监控 RunLoop 状态
  5. 提供优雅的停止机制

2.2 事件响应优化

class EventResponder {private var eventQueue: [Any] = []private var isProcessing = falsefunc handleEvent(_ event: Any) {eventQueue.append(event)if !isProcessing {isProcessing = trueperform(#selector(processNextEvent),with: nil,afterDelay: 0,inModes: [.default])}}@objc private func processNextEvent() {guard !eventQueue.isEmpty else {isProcessing = falsereturn}let event = eventQueue.removeFirst()processEvent(event)// 继续处理下一个事件perform(#selector(processNextEvent),with: nil,afterDelay: 0,inModes: [.default])}private func processEvent(_ event: Any) {// 实际的事件处理逻辑print("Processing event: \(event)")}
}

这段代码展示了如何优化事件响应：

  1. 使用队列管理事件
  2. 通过 RunLoop 控制事件处理节奏
  3. 避免事件处理阻塞主线程
  4. 支持事件处理的暂停和恢复

四、RunLoop 常见问题与解决方案

1. 常见问题

  1. NSTimer 不触发

    • 原因：RunLoop Mode 不匹配
    • 解决方案：使用 NSRunLoopCommonModes

  2. 子线程任务不执行

    • 原因：子线程 RunLoop 未启动
    • 解决方案：手动启动 RunLoop

  3. 主线程卡顿

    • 原因：RunLoop 中执行耗时操作
    • 解决方案：将耗时操作放到子线程

2. 调试技巧

  • 使用 CFRunLoopObserver 监控 RunLoop 状态
  • 使用 Instruments 的 Time Profiler 分析性能
  • 使用 NSLog 打印 RunLoop 状态变化

总结

RunLoop 是 iOS 系统中处理事件和消息的核心机制，它通过循环处理来保持程序持续运行并响应各种事件。每个线程都有且只有一个对应的 RunLoop，主线程的 RunLoop 默认开启，而子线程需要手动开启。RunLoop 的核心组件包括 CFRunLoopRef、CFRunLoopMode、CFRunLoopSource、CFRunLoopTimer 和 CFRunLoopObserver，它们共同构成了一个完整的事件处理系统。RunLoop 的工作流程包括事件处理、休眠和唤醒等步骤，通过合理使用 RunLoop Mode 和优化定时器，可以有效提升应用性能。在实际应用中，RunLoop 常用于常驻线程、事件响应优化和性能监控等场景。掌握 RunLoop 的原理和应用，对于开发高性能的 iOS 应用至关重要。

如果觉得本文对你有帮助，欢迎点赞、收藏、关注我，后续会持续分享更多 iOS 底层原理与实战经验

相关文章：

  • ZStack Cloud 5.3.28正式发布
  • macOS 安装了Docker Desktop版终端docker 命令没办法使用
  • 如何选择合适的铸铁地板？在工业行业靠什么优势稳步前进？（北重）
  • PostgreSQL中的SSL（2）
  • 提高程序灵活性和效率的利器：Natasha动态编译库【.Net】
  • React-Native Android 多行被截断
  • layui轮播图根据设备宽度图片等比例，高度自适应
  • 一、Javaweb是什么？
  • 海外社交软件技术深潜：实时互动系统与边缘计算的极限优化
  • JavaScript的3D库有哪些？
  • 2025-03 机器人等级考试三级理论真题 3级
  • 论文阅读：2024 EMNLP User Inference Attacks on Large Language Models
  • 【大模型系列篇】Qwen3开源全新一代大语言模型来了，深入思考，更快行动
  • OpenCV 图像处理核心技术 (第二部分)
  • Spring Boot 实现多种来源的 Zip 多层目录打包下载（本地文件HTTP混合）
  • 深入理解CSS显示模式与盒子模型
  • 麒麟（Kylin）系统下安装MySQL 8.4.5（离线版）
  • （32）VTK C++开发示例 ---背景纹理
  • C语言实现库函数strlen
  • 运维仙途 第1章 灵机突现探监控
  • 国有六大行一季度合计净赚超3444亿，不良贷款余额均上升
  • 深入贯彻中央八项规定精神学习教育中央指导组派驻地方和单位名单公布
  • 外交部：美方应在平等、尊重和互惠的基础上同中方开展对话
  • 西班牙葡萄牙电力基本恢复
  • 北京动物园：大熊猫“萌兰”没有参加日本大阪世博会的计划
  • 圆桌｜特朗普上台百日未能结束俄乌冲突，若美国“退出”会发生什么？