MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Swift并发编程进阶

2021-11-142.6k 阅读

一、Swift 并发编程基础回顾

在深入 Swift 并发编程进阶内容之前，让我们先简单回顾一下基础概念。Swift 5.5 引入了基于结构化并发的异步编程模型，主要通过 async 和 await 关键字来实现异步操作。

1.1 异步函数

一个异步函数使用 async 关键字标记，它表示该函数可能会异步执行任务。例如：

func fetchData() async -> Data? {
    // 模拟异步操作，这里可能是网络请求等
    let delay = Int.random(in: 1...3)
    try? await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
    return Data("Sample Data".utf8)
}

在这个函数中，await Task.sleep(nanoseconds: ...) 模拟了一个异步的等待操作，await 关键字用于暂停函数执行，直到异步任务完成。

1.2 异步任务调用

当调用异步函数时，需要在 await 关键字前加上 try（如果函数可能抛出错误）。例如：

func processData() async {
    if let data = try? await fetchData() {
        if let string = String(data: data, encoding:.utf8) {
            print("Received data: \(string)")
        }
    }
}

这里在 processData 函数中调用 fetchData 时使用了 await，确保只有在数据获取完成后才继续执行后续处理。

二、任务组（Task Groups）

任务组是 Swift 并发编程中的一个强大特性，它允许我们在一个逻辑单元内并发执行多个任务，并等待所有任务完成。

2.1 创建和使用任务组

通过 Task.group 来创建任务组。例如，假设我们有多个独立的网络请求需要并发执行：

func concurrentNetworkRequests() async {
    let urls = [
        URL(string: "https://example.com/api1")!,
        URL(string: "https://example.com/api2")!,
        URL(string: "https://example.com/api3")!
    ]
    
    let results = await withThrowingTaskGroup(of: Data?.self) { group in
        for url in urls {
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return data
            }
        }
        
        var allResults: [Data?] = []
        for try await result in group {
            allResults.append(result)
        }
        return allResults
    }
    
    for (index, result) in results.enumerated() {
        if let data = result, let string = String(data: data, encoding:.utf8) {
            print("Result from request \(index + 1): \(string)")
        }
    }
}

在这个例子中，withThrowingTaskGroup 创建了一个任务组，group.addTask 添加了多个任务，每个任务执行一个网络请求。for try await result in group 循环等待所有任务完成，并收集结果。

2.2 任务组的错误处理

如果任务组中的某个任务抛出错误，整个任务组会立即停止，并且 withThrowingTaskGroup 会抛出该错误。例如：

func concurrentNetworkRequestsWithError() async {
    let urls = [
        URL(string: "https://example.com/api1")!,
        URL(string: "https://example.com/invalid-url")!,
        URL(string: "https://example.com/api3")!
    ]
    
    do {
        let results = try await withThrowingTaskGroup(of: Data?.self) { group in
            for url in urls {
                group.addTask {
                    let (data, _) = try await URLSession.shared.data(from: url)
                    return data
                }
            }
            
            var allResults: [Data?] = []
            for try await result in group {
                allResults.append(result)
            }
            return allResults
        }
        
        for (index, result) in results.enumerated() {
            if let data = result, let string = String(data: data, encoding:.utf8) {
                print("Result from request \(index + 1): \(string)")
            }
        }
    } catch {
        print("An error occurred: \(error)")
    }
}

这里第二个 URL 是无效的，当执行到该任务时会抛出错误，整个任务组停止，do - catch 块捕获并处理该错误。

三、异步序列（Async Sequences）

异步序列是一种能够异步生成值的序列。它允许我们以一种类似于处理普通序列的方式来处理异步数据。

3.1 定义异步序列

假设我们有一个模拟从服务器分批获取数据的异步序列：

struct AsyncDataFetcher: AsyncSequence {
    typealias Element = Data
    
    let url: URL
    let batchSize: Int
    
    func makeAsyncIterator() -> AsyncDataFetcherIterator {
        AsyncDataFetcherIterator(url: url, batchSize: batchSize)
    }
}

class AsyncDataFetcherIterator: AsyncIteratorProtocol {
    let url: URL
    let batchSize: Int
    var offset = 0
    
    init(url: URL, batchSize: Int) {
        self.url = url
        self.batchSize = batchSize
    }
    
    func next() async throws -> Data? {
        let request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.httpBody = try? JSONSerialization.data(withJSONObject: ["offset": offset, "limit": batchSize])
        
        let (data, _) = try await URLSession.shared.data(for: request)
        offset += batchSize
        return data.isEmpty? nil : data
    }
}

在这个例子中，AsyncDataFetcher 定义了一个异步序列，AsyncDataFetcherIterator 实现了异步迭代器协议，每次 next 调用会异步获取一批数据。

3.2 使用异步序列

我们可以使用 for - await - in 循环来遍历异步序列，就像遍历普通序列一样：

func processAsyncData() async {
    let fetcher = AsyncDataFetcher(url: URL(string: "https://example.com/api/data")!, batchSize: 1024)
    for await data in fetcher {
        if let string = String(data: data, encoding:.utf8) {
            print("Received batch of data: \(string)")
        }
    }
}

这个循环会异步地获取数据批次，并在获取到每一批数据后进行处理。

四、Actor

Actor 是 Swift 并发编程中用于解决共享可变状态并发访问问题的重要概念。

4.1 定义 Actor

假设我们有一个银行账户类，需要在多线程环境下安全地操作余额：

actor BankAccount {
    var balance: Double
    
    init(balance: Double) {
        self.balance = balance
    }
    
    func deposit(amount: Double) {
        balance += amount
    }
    
    func withdraw(amount: Double) -> Bool {
        if balance >= amount {
            balance -= amount
            return true
        }
        return false
    }
}

在这个 BankAccount actor 中，balance 是共享可变状态，deposit 和 withdraw 方法对其进行操作。由于 actor 的特性，这些方法的调用会被序列化，避免了并发访问冲突。

4.2 访问 Actor

当我们想要访问 actor 中的方法时，需要使用 await 关键字。例如：

func performBankOperations() async {
    let account = BankAccount(balance: 1000.0)
    
    let task1 = Task {
        await account.deposit(amount: 500.0)
        print("Deposited 500, new balance: \(await account.balance)")
    }
    
    let task2 = Task {
        if await account.withdraw(amount: 300.0) {
            print("Withdrew 300, new balance: \(await account.balance)")
        } else {
            print("Insufficient funds")
        }
    }
    
    await task1.value
    await task2.value
}

在这个例子中，task1 和 task2 并发地尝试访问 BankAccount actor 的方法，由于 actor 的机制，这些操作会安全地序列化执行。

五、并发调度与优先级

Swift 提供了对任务调度和优先级设置的支持，这对于优化应用性能非常重要。

5.1 任务调度

我们可以通过 Task 的 init 方法来指定任务的调度方式。例如，将任务调度到后台队列：

func backgroundTask() async {
    let task = Task {
        // 模拟一些耗时操作
        for _ in 0..<1000000 {
            _ = sin(Double.random(in: 0...100))
        }
        print("Background task completed")
    }
    await task.value
}

默认情况下，任务会在当前的调度上下文中执行。通过 Task 的 init 方法的 operationQueue 参数，可以将任务调度到特定的队列，如后台队列。

5.2 任务优先级

任务可以设置优先级，Swift 提供了 TaskPriority 枚举来表示不同的优先级级别，如 .high、.medium（默认）和 .low。例如：

func highPriorityTask() async {
    let task = Task(priority:.high) {
        // 重要且紧急的任务操作
        print("High priority task started")
        // 模拟一些重要计算
        let result = (1...10000).reduce(0) { $0 + $1 }
        print("High priority task result: \(result)")
    }
    await task.value
}

通过设置高优先级，系统会尽量优先执行该任务，对于一些对时间敏感的操作非常有用。

六、并发编程中的错误处理

在并发编程中，错误处理尤为重要，因为多个异步任务可能会同时抛出错误。

6.1 统一错误处理

对于任务组中的错误，我们可以在 withThrowingTaskGroup 中进行统一处理，如前文提到的 concurrentNetworkRequestsWithError 函数。对于单个异步函数，我们可以使用 do - catch 块。例如：

func singleAsyncFunctionWithError() async {
    do {
        let data = try await fetchData()
        if let string = String(data: data, encoding:.utf8) {
            print("Received data: \(string)")
        }
    } catch {
        print("Error fetching data: \(error)")
    }
}

这里 fetchData 函数可能抛出错误，do - catch 块捕获并处理该错误。

6.2 自定义错误类型

在实际应用中，我们通常会定义自己的错误类型，以便更好地处理特定的错误情况。例如：

enum NetworkError: Error {
    case invalidURL
    case requestFailed
    case decodingError
}

func fetchDataWithCustomError() async throws -> Data {
    let url = URL(string: "https://example.com/invalid - url")
    guard let validURL = url else {
        throw NetworkError.invalidURL
    }
    
    do {
        let (data, _) = try await URLSession.shared.data(from: validURL)
        return data
    } catch {
        throw NetworkError.requestFailed
    }
}

在这个函数中，我们定义了 NetworkError 枚举来表示不同类型的网络错误，并在函数中根据不同情况抛出相应的错误。调用该函数时，可以根据 NetworkError 进行更细致的错误处理。

七、与传统异步编程的交互

在实际项目中，可能会存在一些使用传统异步编程（如基于回调或 DispatchQueue）的代码，需要与新的 Swift 并发模型进行交互。

7.1 从传统回调转换为异步函数

假设我们有一个基于回调的网络请求函数：

func legacyNetworkRequest(url: URL, completion: @escaping (Data?, Error?) -> Void) {
    let task = URLSession.shared.dataTask(with: url) { data, response, error in
        completion(data, error)
    }
    task.resume()
}

我们可以将其转换为异步函数：

func modernNetworkRequest(url: URL) async throws -> Data {
    try await withCheckedThrowingContinuation { continuation in
        legacyNetworkRequest(url: url) { data, error in
            if let error = error {
                continuation.resume(throwing: error)
            } else if let data = data {
                continuation.resume(returning: data)
            } else {
                continuation.resume(throwing: NSError(domain: "NetworkErrorDomain", code: -1, userInfo: nil))
            }
        }
    }
}

这里使用 withCheckedThrowingContinuation 将基于回调的函数转换为异步函数，使得它可以与新的并发模型无缝集成。

7.2 在异步函数中使用 DispatchQueue

有时候，我们可能需要在异步函数中使用 DispatchQueue 来执行一些特定的任务。例如：

func asyncFunctionWithDispatchQueue() async {
    let queue = DispatchQueue(label: "com.example.customQueue")
    queue.async {
        // 这里执行一些与并发模型无关的特定任务，如文件写入等
        print("Task executed on custom dispatch queue")
    }
    
    // 异步函数的其他异步操作
    let data = try? await fetchData()
    if let data = data, let string = String(data: data, encoding:.utf8) {
        print("Received data: \(string)")
    }
}

在这个例子中，我们在异步函数中创建了一个 DispatchQueue 并异步执行了一个任务，同时还进行了其他异步操作，展示了如何在新的并发模型中兼容传统的 DispatchQueue 使用。

八、性能优化与并发编程

并发编程的目的之一是提高应用的性能，但不当的使用可能会导致性能下降。

8.1 避免过度并发

虽然并发可以提高效率，但创建过多的任务会消耗系统资源，导致性能下降。例如，在一个循环中创建大量的任务可能会使系统不堪重负。我们应该根据实际情况合理控制任务的数量。例如，在进行批量网络请求时，可以限制同时进行的请求数量：

func limitedConcurrentNetworkRequests() async {
    let urls = [
        URL(string: "https://example.com/api1")!,
        URL(string: "https://example.com/api2")!,
        URL(string: "https://example.com/api3")!,
        URL(string: "https://example.com/api4")!,
        URL(string: "https://example.com/api5")!
    ]
    
    let semaphore = DispatchSemaphore(value: 3) // 最多同时执行 3 个任务
    
    let tasks = urls.map { url in
        Task {
            semaphore.wait()
            defer { semaphore.signal() }
            let (data, _) = try await URLSession.shared.data(from: url)
            return data
        }
    }
    
    let results = await withThrowingTaskGroup(of: Data?.self) { group in
        for task in tasks {
            group.addTask { try await task.value }
        }
        
        var allResults: [Data?] = []
        for try await result in group {
            allResults.append(result)
        }
        return allResults
    }
    
    for (index, result) in results.enumerated() {
        if let data = result, let string = String(data: data, encoding:.utf8) {
            print("Result from request \(index + 1): \(string)")
        }
    }
}

这里使用 DispatchSemaphore 来限制同时执行的网络请求任务数量为 3，避免过度并发。

8.2 优化任务粒度

任务的粒度也会影响性能。如果任务过于细化，任务创建和调度的开销可能会超过任务本身执行的时间。例如，将一个大的计算任务分割成非常小的子任务并发执行，可能会因为任务调度开销而导致性能降低。我们应该根据任务的性质和计算量来合理划分任务粒度。

假设我们有一个大的数组需要进行计算，我们可以选择将数组分成适当大小的块进行并发计算：

func largeArrayCalculation() async {
    let largeArray = Array(1...1000000)
    let numChunks = 10
    let chunkSize = largeArray.count / numChunks
    
    let tasks = (0..<numChunks).map { index in
        Task {
            let startIndex = index * chunkSize
            let endIndex = (index == numChunks - 1)? largeArray.count : (index + 1) * chunkSize
            let subArray = Array(largeArray[startIndex..<endIndex])
            return subArray.reduce(0) { $0 + $1 }
        }
    }
    
    let results = await withThrowingTaskGroup(of: Int.self) { group in
        for task in tasks {
            group.addTask { try await task.value }
        }
        
        var allResults: [Int] = []
        for try await result in group {
            allResults.append(result)
        }
        return allResults
    }
    
    let total = results.reduce(0) { $0 + $1 }
    print("Total result: \(total)")
}

在这个例子中，我们将大数组分成 10 个块，每个块作为一个任务进行并发计算，这样既利用了并发优势，又避免了任务粒度太细导致的性能问题。

九、并发编程中的内存管理

在并发编程中，内存管理也面临一些挑战，因为多个任务可能同时访问和修改内存中的数据。

9.1 避免内存泄漏

在使用任务组和异步序列时，要确保所有资源都被正确释放。例如，在网络请求任务中，如果没有正确处理响应数据和关闭连接，可能会导致内存泄漏。在异步序列中，如果迭代器没有正确释放资源，也会出现类似问题。

假设我们有一个自定义的资源管理类：

class Resource {
    init() {
        print("Resource initialized")
    }
    
    deinit {
        print("Resource deallocated")
    }
}

func taskWithResource() async {
    var resource: Resource? = Resource()
    let task = Task {
        // 任务执行一些操作
        await Task.sleep(nanoseconds: 2_000_000_000)
        resource = nil // 手动释放资源
    }
    await task.value
}

在这个例子中，我们在任务结束前手动将 resource 设置为 nil，确保资源被正确释放，避免内存泄漏。

9.2 内存竞争与数据一致性

在多个任务同时访问和修改共享内存时，可能会出现内存竞争问题，导致数据不一致。Actor 是解决这个问题的有效方式，但在使用其他并发机制时，需要特别注意。

例如，在没有使用 actor 的情况下，如果多个任务同时修改一个共享的可变数组：

var sharedArray: [Int] = []

func concurrentArrayModification() async {
    let task1 = Task {
        for _ in 0..<100 {
            sharedArray.append(1)
        }
    }
    
    let task2 = Task {
        for _ in 0..<100 {
            sharedArray.append(2)
        }
    }
    
    await task1.value
    await task2.value
    print("Shared array: \(sharedArray)")
}

由于两个任务同时修改 sharedArray，可能会导致数据不一致。我们可以通过使用 actor 或者其他同步机制（如锁）来解决这个问题。

十、并发编程在实际项目中的应用场景

10.1 网络请求

在移动应用开发中，网络请求是最常见的异步操作。通过并发编程，可以同时发起多个网络请求，提高数据获取的效率。例如，在一个新闻应用中，可以同时请求新闻列表数据和用户个性化推荐数据，然后合并处理显示。

10.2 数据处理与计算

对于一些需要大量计算的任务，如图片处理、数据分析等，可以将任务分割并发执行，加快处理速度。例如，在一个图像处理应用中，可以将图片分割成多个区域，并发进行图像增强等操作，然后合并结果。

10.3 多线程用户界面更新

在 iOS 开发中，用户界面更新必须在主线程进行。但一些耗时操作（如网络请求、数据处理）不应该阻塞主线程。通过并发编程，我们可以在后台线程执行这些操作，然后在主线程更新界面。例如，在一个聊天应用中，接收新消息的网络请求可以在后台线程进行，当收到消息后，在主线程更新聊天界面。

通过深入理解和应用 Swift 并发编程的这些进阶特性，开发者可以编写出更高效、更健壮的应用程序，充分利用现代多核处理器的优势，提升用户体验。在实际开发中，需要根据具体的业务需求和场景，合理选择和组合这些并发编程技术，以达到最佳的性能和稳定性。