iOS多线程编程

#import <pthread.h>

void *threadFunction(void *param) {
    NSLog(@"pthread执行任务: %@", [NSThread currentThread]);
    return NULL;
}

- (void)createPthread {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
}

// 方式1：实例方法创建，需要手动启动
NSThread *thread = [[NSThread alloc] initWithTarget:self 
                                           selector:@selector(doTask) 
                                             object:nil];
thread.name = @"MyThread";
[thread start];

// 方式2：类方法创建，自动启动
[NSThread detachNewThreadSelector:@selector(doTask) 
                         toTarget:self 
                       withObject:nil];

// 方式3：隐式创建
[self performSelectorInBackground:@selector(doTask) withObject:nil];

// 获取当前线程
NSThread *currentThread = [NSThread currentThread];

// 获取主线程
NSThread *mainThread = [NSThread mainThread];

// 判断是否是主线程
BOOL isMain = [NSThread isMainThread];

// 线程休眠
[NSThread sleepForTimeInterval:2.0];
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2.0]];

// 退出当前线程
[NSThread exit];

// 回到主线程执行
[self performSelectorOnMainThread:@selector(updateUI) 
                       withObject:nil 
                    waitUntilDone:NO];

// 在指定线程执行
[self performSelector:@selector(doTask) 
             onThread:thread 
           withObject:nil 
        waitUntilDone:NO];

dispatch_queue_t serialQueue = dispatch_queue_create("com.example.serial", DISPATCH_QUEUE_SERIAL);

dispatch_queue_t concurrentQueue = dispatch_queue_create("com.example.concurrent", DISPATCH_QUEUE_CONCURRENT);

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_queue_t globalQueue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

// 同步执行 - 阻塞当前线程，等待block执行完毕后才返回
dispatch_sync(queue, ^{
    NSLog(@"同步任务");
});
NSLog(@"同步任务完成后才会打印");

// 异步执行 - 不阻塞当前线程，立即返回
dispatch_async(queue, ^{
    NSLog(@"异步任务");
});
NSLog(@"这行代码不需要等待异步任务完成");

NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self 
                                                                 selector:@selector(doTask) 
                                                                   object:nil];
// 直接调用start会在当前线程执行
[op start];

// 添加到队列会在子线程执行
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:op];

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务1: %@", [NSThread currentThread]);
}];

[op addExecutionBlock:^{
    NSLog(@"任务2: %@", [NSThread currentThread]);
}];

[op addExecutionBlock:^{
    NSLog(@"任务3: %@", [NSThread currentThread]);
}];

op.completionBlock = ^{
    NSLog(@"所有任务完成");
};

[op start];

@interface CustomOperation : NSOperation
@end

@implementation CustomOperation

- (void)main {
    if (self.isCancelled) return;
    
    // 执行任务
    NSLog(@"自定义任务: %@", [NSThread currentThread]);
    
    if (self.isCancelled) return;
}

@end

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

// 设置最大并发数
queue.maxConcurrentOperationCount = 3;

// 添加操作
[queue addOperation:op];

// 使用block添加操作
[queue addOperationWithBlock:^{
    NSLog(@"任务");
}];

// 获取主队列
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"下载图片");
}];

NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"处理图片");
}];

NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"显示图片");
}];

// 设置依赖关系：op2依赖op1，op3依赖op2
[op2 addDependency:op1];
[op3 addDependency:op2];

[queue addOperations:@[op1, op2, op3] waitUntilFinished:NO];

// 暂停队列：已经在执行中的操作不会被暂停，只是不再调度新的操作
queue.suspended = YES;

// 恢复队列：继续调度队列中等待的操作
queue.suspended = NO;

// 取消所有操作：对每个operation调用cancel，但不会强制停止正在执行的操作，
// 需要在operation的main方法中检查isCancelled来响应取消
[queue cancelAllOperations];

// 等待所有操作完成：会阻塞当前线程，不要在主线程调用
[queue waitUntilAllOperationsAreFinished];

@synchronized (self) {
    // 临界区代码
    self.count++;
}

NSLock *lock = [[NSLock alloc] init];

[lock lock];
// 临界区代码
self.count++;
[lock unlock];

// tryLock 尝试加锁，不会阻塞
if ([lock tryLock]) {
    // 临界区代码
    [lock unlock];
}

NSRecursiveLock *recursiveLock = [[NSRecursiveLock alloc] init];

- (void)recursiveMethod:(int)depth {
    if (depth <= 0) return;
    [recursiveLock lock];
    NSLog(@"depth: %d", depth);
    [self recursiveMethod:depth - 1];
    [recursiveLock unlock];
}

NSCondition *condition = [[NSCondition alloc] init];

// 生产者
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [condition lock];
    // 生产数据
    self.dataReady = YES;
    [condition signal]; // 发送信号
    [condition unlock];
});

// 消费者
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [condition lock];
    while (!self.dataReady) {
        [condition wait]; // 等待信号
    }
    // 消费数据
    [condition unlock];
});

NSConditionLock *conditionLock = [[NSConditionLock alloc] initWithCondition:0];

// 线程1
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [conditionLock lockWhenCondition:0];
    NSLog(@"任务1");
    [conditionLock unlockWithCondition:1];
});

// 线程2
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [conditionLock lockWhenCondition:1];
    NSLog(@"任务2");
    [conditionLock unlockWithCondition:2];
});

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 临界区代码
self.count++;
dispatch_semaphore_signal(semaphore);

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

pthread_mutex_lock(&mutex);
// 临界区代码
self.count++;
pthread_mutex_unlock(&mutex);

pthread_mutex_destroy(&mutex);

#import <os/lock.h>

// 作为实例变量使用，确保锁的内存地址稳定
@implementation MyClass {
    os_unfair_lock _lock;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _lock = OS_UNFAIR_LOCK_INIT;
    }
    return self;
}

- (void)safeIncrement {
    os_unfair_lock_lock(&_lock);
    self.count++;
    os_unfair_lock_unlock(&_lock);
}
@end

@property (atomic, strong) NSString *name;

func fetchData() async throws -> Data {
    try await withCheckedThrowingContinuation { continuation in
        legacyFetchData { result in
            switch result {
            case .success(let data):
                continuation.resume(returning: data)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

func fetchUser() async throws -> User {
    let (data, _) = try await URLSession.shared.data(from: url)  // 挂起点：等待网络请求
    return try JSONDecoder().decode(User.self, from: data)        // 恢复后继续执行
}

let user = try await fetchUser()

// 闭包回调风格：容易产生回调嵌套，错误处理分散
func loadUserProfile(completion: @escaping (Result<Profile, Error>) -> Void) {
    fetchUser { userResult in
        switch userResult {
        case .success(let user):
            fetchProfile(for: user) { profileResult in
                completion(profileResult)
            }
        case .failure(let error):
            completion(.failure(error))
        }
    }
}

// async/await风格：线性书写，错误统一处理
func loadUserProfile() async throws -> Profile {
    let user = try await fetchUser()
    let profile = try await fetchProfile(for: user)
    return profile
}

// 创建非结构化任务
Task {
    let user = try await fetchUser()
    print(user.name)
}

// 创建分离任务（不继承当前上下文）
Task.detached {
    await performBackgroundWork()
}

actor BankAccount {
    private var balance: Int = 0
    
    func deposit(_ amount: Int) {
        balance += amount
    }
    
    func withdraw(_ amount: Int) -> Bool {
        guard balance >= amount else { return false }
        balance -= amount
        return true
    }
    
    // nonisolated：不需要隔离保护的成员，可以同步访问
    // 只能访问不可变状态或不涉及actor状态的计算
    nonisolated var description: String {
        "BankAccount instance"
    }
}

let account = BankAccount()
await account.deposit(100)  // 从外部访问actor需要await（跨隔离域）

actor ImageCache {
    private var cache: [URL: Image] = [:]
    
    func getImage(for url: URL) async throws -> Image {
        if let cached = cache[url] { return cached }
        
        let image = try await downloadImage(from: url)
        // ⚠️ await之后cache[url]可能已被其他任务修改
        // 应检查是否已有缓存，避免覆盖
        cache[url] = cache[url] ?? image
        return cache[url]!
    }
}

// 标记整个类：所有属性和方法默认在主线程执行
@MainActor
class ViewModel: ObservableObject {
    @Published var users: [User] = []
    
    func loadUsers() async {
        let users = try? await fetchUsers()  // await处可能切到后台线程执行网络请求
        self.users = users ?? []             // 回到主线程更新UI
    }
}

// 标记单个函数
@MainActor
func updateUI() {
    label.text = "Updated"
}

// 在非MainActor上下文中临时切到主线程
func processData() async {
    let result = await computeInBackground()
    await MainActor.run {
        label.text = result  // 确保在主线程更新
    }
}

func fetchAllUsers(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids {
            group.addTask {
                try await fetchUser(id: id)
            }
        }
        
        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
}

try await withThrowingTaskGroup(of: User?.self) { group in
    for id in ids {
        group.addTask {
            try? await fetchUser(id: id)  // 单个失败返回nil，不影响其他任务
        }
    }
    var users: [User] = []
    for try await user in group {
        if let user { users.append(user) }
    }
    return users
}

func loadDashboard() async throws -> Dashboard {
    async let user = fetchUser()
    async let posts = fetchPosts()
    async let notifications = fetchNotifications()
    
    // 三个请求从声明时就开始并发执行，此处等待所有结果
    return try await Dashboard(
        user: user,
        posts: posts,
        notifications: notifications
    )
}

func example() async throws -> User {
    async let user = fetchUser()
    async let analytics = trackPageView()  // 如果fetchUser抛出错误...
    
    let result = try await user             // ...这里抛出异常
    _ = try await analytics
    return result
    // analytics任务会被自动取消并等待结束，不会泄漏
}

// 值类型：所有属性都是Sendable，自动满足
struct User: Sendable {
    let id: Int
    let name: String
}

// final class + 全部let属性：可以显式声明Sendable
final class Config: Sendable {
    let apiKey: String
    init(apiKey: String) { self.apiKey = apiKey }
}

// Actor自动满足Sendable
actor DataStore: Sendable { }

final class ThreadSafeCache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Any] = [:]
    
    func set(_ value: Any, for key: String) {
        lock.lock()
        storage[key] = value
        lock.unlock()
    }
}

var count = 0
Task { @Sendable in
    // ❌ 编译错误：捕获了外部可变变量
    // count += 1
}

// 逐行异步读取URL内容
let url = URL(string: "https://example.com/data.txt")!
for try await line in url.lines {
    print(line)
}

// 异步监听通知
let notifications = NotificationCenter.default.notifications(named: .userDidLogin)
for await notification in notifications {
    handleLogin(notification)
}

// 将CLLocationManager的delegate回调桥接为AsyncStream
func locationUpdates() -> AsyncStream<CLLocation> {
    AsyncStream { continuation in
        let delegate = LocationDelegate(
            onUpdate: { location in
                continuation.yield(location)
            },
            onFinish: {
                continuation.finish()
            }
        )
        
        continuation.onTermination = { _ in
            // 清理资源
        }
        
        locationManager.delegate = delegate
        locationManager.startUpdatingLocation()
    }
}

// 消费
for await location in locationUpdates() {
    updateMap(with: location)
}

// 死锁示例1：主线程同步执行主队列任务
// 主线程正在执行当前代码 → sync将block排到主队列尾部 → 主线程阻塞等待block完成 → block等待当前代码执行完才能执行
DispatchQueue.main.sync {
    print("这里永远不会执行")
}

// 死锁示例2：串行队列中同步执行当前队列任务
let queue = DispatchQueue(label: "com.example")
queue.async {
    // 当前已经在queue上执行
    queue.sync {
        // sync将block排到queue尾部，但queue要等当前block完成才能执行下一个
        print("死锁")
    }
}

let lockA = NSLock()
let lockB = NSLock()

// 线程1
DispatchQueue.global().async {
    lockA.lock()
    Thread.sleep(forTimeInterval: 0.1)
    lockB.lock()    // 等待线程2释放lockB
    lockB.unlock()
    lockA.unlock()
}

// 线程2
DispatchQueue.global().async {
    lockB.lock()
    Thread.sleep(forTimeInterval: 0.1)
    lockA.lock()    // 等待线程1释放lockA → 循环等待，死锁
    lockA.unlock()
    lockB.unlock()
}

时间线 →

低优先级线程:   [获取锁]---[执行中...]----------------------------[释放锁]
中优先级线程:          [抢占CPU]---[长时间执行]---[完成]
高优先级线程:              [自旋等待锁...]---[被中优先级间接阻塞...]---[终于获取锁]

class ReadWriteStore {
    private let queue = DispatchQueue(label: "com.example.rwlock", attributes: .concurrent)
    private var _data: Any?

    func readData() -> Any? {
        queue.sync {
            _data
        }
    }

    func writeData(_ data: Any?) {
        queue.async(flags: .barrier) {
            self._data = data
        }
    }
}