iOS开发多线程技术概览在iOS开发中，多线程是实现高性能和响应式应用的关键技术。以下从Objective-C和Swif

在iOS开发中，多线程是实现高性能和响应式应用的关键技术。以下从Objective-C和Swift两个语言角度，系统梳理iOS多线程核心模块及其使用方式：

一、多线程技术概览

iOS中主要多线程技术包括：

Thread：轻量级线程管理
GCD (Grand Central Dispatch) ：基于队列的任务调度
OperationQueue：面向对象的高级任务管理

二、Objective-C中的实现

1. NSThread

// 显式创建线程
NSThread *thread = [[NSThread alloc] initWithTarget:self 
                                          selector:@selector(threadTask:) 
                                            object:nil];
[thread start];

// 隐式创建
[NSThread detachNewThreadSelector:@selector(threadTask:) 
                         toTarget:self 
                       withObject:nil];

// NSObject后台线程
[self performSelectorInBackground:@selector(threadTask:) withObject:nil];

特点：需要手动管理生命周期，适合简单任务

2. GCD

// 获取队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t customQueue = dispatch_queue_create("com.example.queue", DISPATCH_QUEUE_SERIAL);

// 异步任务
dispatch_async(globalQueue, ^{
    // 后台任务
    dispatch_async(mainQueue, ^{
        // 更新UI
    });
});

// 同步任务（谨慎使用）
dispatch_sync(customQueue, ^{ /* 同步执行 */ });

// 高级功能
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, globalQueue, ^{ /* 任务1 */ });
dispatch_group_notify(group, mainQueue, ^{ /* 任务完成回调 */ });

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), mainQueue, ^{
    // 延迟执行
});

3. NSOperationQueue

// 创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
queue.maxConcurrentOperationCount = 3;

// 创建任务
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{ /* 任务1 */ }];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{ /* 任务2 */ }];

// 添加依赖
[op2 addDependency:op1];

// 添加任务到队列
[queue addOperations:@[op1, op2] waitUntilFinished:NO];

// 自定义Operation
@interface MyOperation : NSOperation
@end
@implementation MyOperation
- (void)main {
    if (!self.isCancelled) {
        // 执行任务
    }
}
@end

优势：支持任务依赖、优先级、取消机制

三、Swift中的实现

1. Thread

// 显式创建
let thread = Thread(target: self, selector: #selector(threadTask), object: nil)
thread.start()

// 隐式创建
Thread.detachNewThreadSelector(#selector(threadTask), toTarget: self, with: nil)

// NSObject方式
self.performSelector(inBackground: #selector(threadTask), with: nil)

2. GCD（Swift风格API）

// 获取队列
let mainQueue = DispatchQueue.main
let globalQueue = DispatchQueue.global(qos: .default)
let customQueue = DispatchQueue(label: "com.example.queue", 
                              attributes: [.concurrent])

// 异步任务
globalQueue.async {
    // 后台任务
    mainQueue.async {
        // 更新UI
    }
}

// 同步任务
customQueue.sync { /* 同步执行 */ }

// 高级功能
let group = DispatchGroup()
globalQueue.async(group: group) { /* 任务1 */ }
group.notify(queue: .main) { /* 完成回调 */ }

mainQueue.asyncAfter(deadline: .now() + 2) {
    // 延迟执行
}

// 信号量
let semaphore = DispatchSemaphore(value: 1)
semaphore.wait()
// 临界区代码
semaphore.signal()

3. OperationQueue

let queue = OperationQueue()
queue.maxConcurrentOperationCount = 3

let op1 = BlockOperation {
    // 任务1
}
let op2 = BlockOperation {
    // 任务2
}

op2.addDependency(op1)
queue.addOperations([op1, op2], waitUntilFinished: false)

// 自定义Operation
class MyOperation: Operation {
    override func main() {
        guard !isCancelled else { return }
        // 执行任务
    }
}

四、语言差异对比

特性	Objective-C	Swift
GCD API	C风格函数 (dispatch_async)	面向对象风格 (DispatchQueue)
闭包语法	Block语法 (^{ ... })	Trailing闭包 + 简洁语法
线程安全	@synchronized 或 NSLock	NSLock/DispatchQueue + 值类型优化
错误处理	NSError指针传递	try/catch + throws机制

五、技术选型建议

简单异步任务：优先使用GCD
复杂任务管理：OperationQueue（依赖关系/取消）
底层控制：Thread（需谨慎处理生命周期）
资源竞争处理：
- GCD Barrier：保证数据读写安全
```
customQueue.async(flags: .barrier) { /* 写操作 */ }
```
- Semaphore：控制并发数量
- Actor（Swift 5.5+）：新的并发安全模型

六、注意事项

主线程规则：所有UI更新必须在主线程执行
线程安全：共享资源需同步访问
避免死锁：谨慎使用同步任务（尤其是主线程）
内存管理：
- Objective-C：Block内使用__weak避免循环引用
- Swift：使用[weak self]捕获列表
性能优化：
- 控制线程数量（建议不超过CPU核心数2倍）
- 优先使用系统提供的并发队列

七、现代并发模型（Swift 5.5+）

虽然不属于传统多线程，但值得关注：

// async/await
func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// Actor
actor DataStore {
    private var data: [String] = []
    
    func add(_ item: String) {
        data.append(item)
    }
}

通过合理选择多线程技术，可以显著提升iOS应用的性能和用户体验。建议结合具体场景选择最合适的方案，并始终注意线程安全和资源管理。