作为 iOS 资深开发，线程常驻是底层线程开发的高阶技能，核心用于高频轻量任务、音视频数据流、长连接等极致性能场景。它的本质是通过 RunLoop 保活子线程，让线程执行完任务后不销毁，一直等待新任务。

本文将从核心原理、优劣分析、生产级高级写法、避免方案四个维度深度拆解，并提供 Objective-C + Swift 双语言完整示例。

---

一、核心原理：线程常驻的底层逻辑

1. 默认线程生命周期

iOS 普通子线程（NSThread/pthread）执行流程：创建线程 → 执行任务 → 任务完成 → 线程自动销毁缺点：频繁创建 / 销毁线程会产生巨大性能开销。

2. 线程常驻核心机制

RunLoop 保活：给子线程绑定一个无限循环的 RunLoop，添加空输入源防止 RunLoop 立即退出，让线程进入休眠状态（不消耗 CPU），实现永久存活。

• 关键 API：CFRunLoopAddSource（添加保活源）、CFRunLoopRun（启动循环）、CFRunLoopStop（停止循环）
• 核心：RunLoop 不退出 → 线程不销毁

3. 适用边界

仅用于高频、轻量、低延迟任务（日志上报、埋点、音视频编解码、长连接心跳）；普通业务绝对禁止使用。

---

二、线程常驻的 优势 VS 劣势（资深视角）

✅ 核心优势

1. 极致性能：避免线程频繁创建 / 销毁（线程是操作系统重量级资源，创建耗时≈100ms）
2. 低延迟响应：任务直达常驻线程，无线程创建耗时
3. 资源可控：专用线程处理特定任务，不与业务线程竞争
4. 长连接保活：网络长连接、音视频流必须用常驻线程保证链路不中断

❌ 致命劣势

1. 内存泄漏风险：忘记停止 RunLoop → 线程永久驻留内存，无法释放
2. 系统资源浪费：常驻线程会占用系统线程池配额，过多会导致 APP 卡顿
3. 维护成本极高：手动管理 RunLoop、线程安全、生命周期，极易出现死锁 / 野指针
4. 违背系统设计：GCD/NSOperation 已自动实现线程复用，手动常驻是兜底方案

---

三、线程常驻 高级写法（生产级封装）

基础版仅用于理解原理，工程中必须用高级封装版：单例复用、线程安全任务队列、优雅退出、无内存泄漏。线程常驻仅支持 NSThread（pthread），GCD 无法手动实现常驻（系统自动管理线程）。

方案 1：Objective-C 高级常驻线程

objectivec

#import <Foundation/Foundation.h>

@interface ResidentThread : NSObject
/// 单例全局常驻线程
+ (instancetype)sharedThread;
/// 异步执行任务
- (void)executeTask:(dispatch_block_t)task;
/// 优雅退出线程（必须调用，防止内存泄漏）
- (void)stopThread;
@end

// ====================== 实现 ======================
#import "ResidentThread.h"

@interface ResidentThread ()
@property (nonatomic, strong) NSThread *residentThread; // 常驻线程
@property (nonatomic, assign) BOOL isStopped;            // 退出标记
@property (nonatomic, strong) NSLock *lock;               // 线程安全锁
@property (nonatomic, strong) NSMutableArray *taskArray; // 任务队列
@end

@implementation ResidentThread

+ (instancetype)sharedThread {
    static ResidentThread *instance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });
    return instance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _isStopped = NO;
        _lock = [[NSLock alloc] init];
        _taskArray = [NSMutableArray array];
        // 创建常驻线程
        __weak typeof(self) weakSelf = self;
        self.residentThread = [[NSThread alloc] initWithTarget:weakSelf selector:@selector(runLoopAction) object:nil];
        self.residentThread.name = @"com.app.resident.thread";
        [self.residentThread start];
    }
    return self;
}

/// RunLoop 保活核心方法
- (void)runLoopAction {
    @autoreleasepool {
        // 1. 添加空输入源，防止RunLoop立即退出
        CFRunLoopSourceContext context = {0};
        CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
        CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
        CFRelease(source);
        
        // 2. 启动RunLoop循环（休眠状态，不消耗CPU）
        while (!self.isStopped) {
            // 执行队列中的任务
            [self.lock lock];
            if (self.taskArray.count > 0) {
                dispatch_block_t task = self.taskArray.firstObject;
                [self.taskArray removeObjectAtIndex:0];
                task();
            }
            [self.lock unlock];
            
            // RunLoop 运行1秒，循环检测
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0, NO);
        }
        
        // 3. 停止RunLoop，线程销毁
        CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
        NSLog(@"常驻线程已销毁");
    }
}

/// 异步添加任务
- (void)executeTask:(dispatch_block_t)task {
    if (!task || self.isStopped) return;
    [self.lock lock];
    [self.taskArray addObject:task];
    [self.lock unlock];
}

/// 优雅退出
- (void)stopThread {
    if (self.isStopped) return;
    self.isStopped = YES;
    // 停止RunLoop
    CFRunLoopStop(CFRunLoopGetCurrent());
    self.residentThread = nil;
}

@end

方案 2：Swift 高级常驻线程

swift

import Foundation

final class ResidentThread {
    // 单例
    static let shared = ResidentThread()
    private init() {
        self.setupThread()
    }
    
    // MARK: - 私有属性
    private var thread: Thread!
    private var isStopped = false
    private let lock = NSLock()
    private var taskArray = [() -> Void]()
    
    // MARK: - 初始化常驻线程
    private func setupThread() {
        thread = Thread(target: self, selector: #selector(runLoopAction), object: nil)
        thread.name = "com.app.resident.thread.swift"
        thread.start()
    }
    
    // MARK: - RunLoop 保活核心
    @objc private func runLoopAction() {
        autoreleasepool {
            // 1. 添加空源，防止RunLoop退出
            let context = CFRunLoopSourceContext()
            let source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, context)
            CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .defaultMode)
            
            // 2. 循环执行任务
            while !isStopped {
                lock.lock()
                if !taskArray.isEmpty {
                    let task = taskArray.removeFirst()
                    task()
                }
                lock.unlock()
                
                // RunLoop 休眠1秒，低功耗
                CFRunLoopRunInMode(.defaultMode, 1.0, false)
            }
            
            // 3. 清理资源
            CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, .defaultMode)
            print("Swift 常驻线程已销毁")
        }
    }
    
    // MARK: - 公开API
    /// 执行任务
    func execute(task: @escaping () -> Void) {
        guard !isStopped else { return }
        lock.lock()
        taskArray.append(task)
        lock.unlock()
    }
    
    /// 优雅退出
    func stop() {
        guard !isStopped else { return }
        isStopped = true
        CFRunLoopStop(CFRunLoopGetCurrent())
    }
}

双语言使用示例

objectivec

// OC 使用
- (void)testResidentThread {
    // 执行任务
    [[ResidentThread sharedThread] executeTask:^{
        NSLog(@"OC 常驻线程执行任务：%@", [NSThread currentThread]);
    }];
    
    // 页面销毁/模块销毁时，必须调用退出！
    // [[ResidentThread sharedThread] stopThread];
}

swift

// Swift 使用
func testResidentThread() {
    // 执行任务
    ResidentThread.shared.execute {
        print("Swift 常驻线程执行任务：Thread.current)")
    }
    
    // 必须在合适时机退出
    // ResidentThread.shared.stop()
}

---

四、如何避免线程常驻？（最优工程实践）

99% 的业务场景，完全不需要手动实现线程常驻！苹果的 GCD / NSOperation 已经内置了线程池复用机制，系统自动管理线程生命周期，比手动常驻更安全、更高效。

替代方案 1：GCD 串行队列（系统自动复用线程）

GCD 会复用空闲线程，不会频繁创建 / 销毁，完美替代手动常驻线程。

objectivec

// OC：GCD 复用线程（推荐）
dispatch_queue_t serialQueue = dispatch_queue_create("com.app.gcd.serial", DISPATCH_QUEUE_SERIAL);
- (void)gcdTask {
    dispatch_async(serialQueue, ^{
        NSLog(@"GCD 复用线程：%@", [NSThread currentThread]);
    });
}

swift

// Swift：GCD 复用线程
private let serialQueue = DispatchQueue(label: "com.app.gcd.serial.swift")
func gcdTask() {
    serialQueue.async {
        print("GCD 复用线程：Thread.current)")
    }
}

替代方案 2：NSOperationQueue（可控并发）

swift

// Swift 操作队列
private let operationQueue = OperationQueue()
init() {
    operationQueue.maxConcurrentOperationCount = 1 // 串行复用
}
func operationTask() {
    let op = BlockOperation {
        print("NSOperation 复用线程")
    }
    operationQueue.addOperation(op)
}

避免线程常驻的核心原则

1. 普通业务 → 用 GCD：系统自动线程复用，零维护成本
2. 复杂任务 → 用 NSOperation：支持依赖 / 取消，自动管理线程
3. 绝对禁止：无理由创建手动常驻线程
4. 必须用常驻：仅音视频、长连接、低延迟心跳等极致场景

---

五、关键避坑指南

1. 必须优雅退出：页面 / 模块销毁时，一定要调用 stopThread 停止 RunLoop，否则内存泄漏
2. 禁止多开：整个 APP 最多创建 1~2 个 常驻线程，过多会耗尽系统线程资源
3. 线程安全：任务队列必须加锁，防止多线程读写崩溃
4. 禁止 UI 操作：常驻线程是子线程，绝对不能更新 UI
5. 低功耗设计：RunLoop 使用 RunInMode 定时休眠，不要无限循环消耗 CPU

---

总结

1. 核心原理：线程常驻 = RunLoop 保活，是底层性能优化方案
2. 高级写法：生产级必须封装单例 + 线程安全队列 + 优雅退出
3. 优劣：性能极致但风险极高，仅用于特殊场景
4. 最优解：优先用 GCD/NSOperation，系统自动线程复用，避免手动常驻
5. 生命周期：常驻线程必须手动退出，否则永久泄漏