在 Swift 中使用 async let 并发运行后台任务

前言

async/await 语法是在 swift 5.5 引入的，在 wwdc 2021中的 meet async/await in swift 对齐进行了介绍。它是编写异步代码的一种更可读的方式，比调度队列和回调函数更容易理解。async/await 语法与其他编程语言（如 c# 或 javascript）中使用的语法类似。使用 "async let "是为了并行的运行多个后台任务，并等待它们的综合结果。

swift 异步编程是一种编写允许某些任务并发运行而不是按顺序运行的代码的方法。这可以提高应用程序的性能，允许它同时执行多个任务，但更重要的是，它可以用来确保用户界面对用户输入的响应，同时任务在后台线程上执行。

长期运行的任务阻塞了ui

在一个同步的程序中，代码以线性的、从上到下的方式运行。程序等待当前任务完成后再进入下一任务。这在用户界面（ui）方面会产生问题，因为如果一个长期运行的任务被同步执行，程序就会阻塞，ui就会变得没有反应，直到任务完成。

下面的代码模拟了一个长期运行的任务，如以同步方式下载一个文件，其结果是ui 变得没有反应，直到任务完成。这样的用户体验是不可接受的。

model:

struct datafile : identifiable, equatable {
    var id: int
    var filesize: int
    var downloadedsize = 0
    var isdownloading = false
    
    init(id: int, filesize: int) {
        self.id = id
        self.filesize = filesize
    }
    
    var progress: double {
        return double(self.downloadedsize) / double(self.filesize)
    }
    
    mutating func increment() {
        if downloadedsize < filesize {
            downloadedsize += 1
        }
    }
}

viewmodel:

class datafileviewmodel: observableobject {
    @published private(set) var file: datafile
    
    init() {
        self.file = datafile(id: 1, filesize: 10)
    }
    
    func downloadfile() {
        file.isdownloading = true

        for _ in 0..<file.filesize {
            file.increment()
            usleep(300000)
        }

        file.isdownloading = false
    }
    
    func reset() {
        self.file = datafile(id: 1, filesize: 10)
    }
}

view:

struct testview1: view {
    @observedobject private var datafiles: datafileviewmodel
    
    init() {
        datafiles = datafileviewmodel()
    }
    
    var body: some view {
        vstack {
            /// 从文末源代码获取其实现
            titleview(title: ["synchronous"])
            
            button("download all") {
                datafiles.downloadfile()
            }
            .buttonstyle(bluebuttonstyle())
            .disabled(datafiles.file.isdownloading)
            
            hstack(spacing: 10) {
                text("file 1:")
                progressview(value: datafiles.file.progress)
                    .frame(width: 180)
                text("\((datafiles.file.progress * 100), specifier: "%0.0f")%")

                zstack {
                    color.clear
                        .frame(width: 30, height: 30)
                    if datafiles.file.isdownloading {
                        progressview()
                            .progressviewstyle(circularprogressviewstyle(tint: .blue))
                    }
                }
            }
            .padding()
            
            spacer().frame(height: 200)

            button("reset") {
                datafiles.reset()
            }
            .buttonstyle(bluebuttonstyle())

            spacer()
        }
        .padding()
    }
}

使用 async/await 在后台执行任务

将 viewmodel 中的downloadfile方法修改为异步的。请注意，由于datafile模型是被视图监听的，对模型的任何改变都需要在ui线程上执行。这是通过使用 mainactor 队列来完成的，即用mainactor.run包裹所有的模型更新。

viewmodel

class datafileviewmodel2: observableobject {
    @published private(set) var file: datafile
    
    init() {
        self.file = datafile(id: 1, filesize: 10)
    }
    
    func downloadfile() async -> int {
        await mainactor.run {
            file.isdownloading = true
        }
        
        for _ in 0..<file.filesize {
            await mainactor.run {
                file.increment()
            }
            usleep(300000)
        }
        
        await mainactor.run {
            file.isdownloading = false
        }
        
        return 1
    }
    
    func reset() {
        self.file = datafile(id: 1, filesize: 10)
    }
}

view：

struct testview2: view {
    @observedobject private var datafiles: datafileviewmodel2
    @state var filecount = 0
    
    init() {
        datafiles = datafileviewmodel2()
    }
    
    var body: some view {
        vstack {
            titleview(title: ["asynchronous"])
            
            button("download all") {
                task {
                    let num = await datafiles.downloadfile()
                    filecount += num
                }
            }
            .buttonstyle(bluebuttonstyle())
            .disabled(datafiles.file.isdownloading)
            
            text("files downloaded: \(filecount)")
            
            hstack(spacing: 10) {
                text("file 1:")
                progressview(value: datafiles.file.progress)
                    .frame(width: 180)
                text("\((datafiles.file.progress * 100), specifier: "%0.0f")%")
                
                zstack {
                    color.clear
                        .frame(width: 30, height: 30)
                    if datafiles.file.isdownloading {
                        progressview()
                            .progressviewstyle(circularprogressviewstyle(tint: .blue))
                    }
                }
            }
            .padding()
            
            spacer().frame(height: 200)
            
            button("reset") {
                datafiles.reset()
            }
            .buttonstyle(bluebuttonstyle())
            
            spacer()
        }
        .padding()
    }
}

在后台执行多个任务

现在我们有一个文件在后台下载，ui显示进度，让我们把它改为多个文件。viewmodel被改为持有一个datafiles数组，而不是一个单一的文件。添加一个downloadfiles方法来遍历所有文件并下载每一个。

视图被绑定到datafiles数组，并更新显示每个文件的下载进度。下载按钮被绑定到异步的downloadfiles中。

viewmodel:

class datafileviewmodel3: observableobject {
    @published private(set) var files: [datafile]
    @published private(set) var filecount = 0
    
    init() {
        files = [
            datafile(id: 1, filesize: 10),
            datafile(id: 2, filesize: 20),
            datafile(id: 3, filesize: 5)
        ]
    }
    
    var isdownloading : bool {
        files.filter { $0.isdownloading }.count > 0
    }
    
    func downloadfiles() async {
        for index in files.indices {
            let num = await downloadfile(index)
            await mainactor.run {
                filecount += num
            }
        }
    }
    
    private func downloadfile(_ index: array<datafile>.index) async -> int {
        await mainactor.run {
            files[index].isdownloading = true
        }
        
        for _ in 0..<files[index].filesize {
            await mainactor.run {
                files[index].increment()
            }
            usleep(300000)
        }
        await mainactor.run {
            files[index].isdownloading = false
        }
        return 1
    }
    
    func reset() {
        files = [
            datafile(id: 1, filesize: 10),
            datafile(id: 2, filesize: 20),
            datafile(id: 3, filesize: 5)
        ]
    }
}

view:

struct testview3: view {
    @observedobject private var datafiles: datafileviewmodel3
    
    init() {
        datafiles = datafileviewmodel3()
    }
    
    var body: some view {
        vstack {
            titleview(title: ["asynchronous", "(multiple files)"])
            
            button("download all") {
                task {
                    await datafiles.downloadfiles()
                }
            }
            .buttonstyle(bluebuttonstyle())
            .disabled(datafiles.isdownloading)
            
            text("files downloaded: \(datafiles.filecount)")
            
            foreach(datafiles.files) { file in
                hstack(spacing: 10) {
                    text("file \(file.id):")
                    progressview(value: file.progress)
                        .frame(width: 180)
                    text("\((file.progress * 100), specifier: "%0.0f")%")
                    
                    zstack {
                        color.clear
                            .frame(width: 30, height: 30)
                        if file.isdownloading {
                            progressview()
                                .progressviewstyle(circularprogressviewstyle(tint: .blue))
                        }
                    }
                }
            }
            .padding()
            
            spacer().frame(height: 150)
            
            button("reset") {
                datafiles.reset()
            }
            .buttonstyle(bluebuttonstyle())
            
            spacer()
        }
        .padding()
    }
}

使用 "async let " 下载多个文件

使用 "async let "来模拟并发下载多个文件的情况

上面的代码可以被改进，以并行地执行多个下载，因为每个任务都是独立于其他任务的。在swift并发中，这是用async let实现的，它用一个承诺立即给一个变量赋值，允许代码执行下一行代码。然后，代码等待这些承诺，等待最终结果的完成。

async/await：

    func downloadfiles() async {
        for index in files.indices {
            let num = await downloadfile(index)
            await mainactor.run {
                filecount += num
            }
        }
    }

async let

    func downloadfiles() async {
        async let num1 = await downloadfile(0)
        async let num2 = await downloadfile(1)
        async let num3 = await downloadfile(2)
        
        let (result1, result2, result3) = await (num1, num2, num3)
        await mainactor.run {
            filecount = result1 + result2 + result3
        }
    }

viewmodel

class datafileviewmodel4: observableobject {
    @published private(set) var files: [datafile]
    @published private(set) var filecount = 0
    
    init() {
        files = [
            datafile(id: 1, filesize: 10),
            datafile(id: 2, filesize: 20),
            datafile(id: 3, filesize: 5)
        ]
    }
    
    var isdownloading : bool {
        files.filter { $0.isdownloading }.count > 0
    }
    
    func downloadfiles() async {
        async let num1 = await downloadfile(0)
        async let num2 = await downloadfile(1)
        async let num3 = await downloadfile(2)
        
        let (result1, result2, result3) = await (num1, num2, num3)
        await mainactor.run {
            filecount = result1 + result2 + result3
        }
    }
    
    private func downloadfile(_ index: array<datafile>.index) async -> int {
        await mainactor.run {
            files[index].isdownloading = true
        }
        
        for _ in 0..<files[index].filesize {
            await mainactor.run {
                files[index].increment()
            }
            usleep(300000)
        }
        await mainactor.run {
            files[index].isdownloading = false
        }
        return 1
    }
    
    
    func reset() {
        files = [
            datafile(id: 1, filesize: 10),
            datafile(id: 2, filesize: 20),
            datafile(id: 3, filesize: 5)
        ]
    }
}

view

struct testview4: view {
    @observedobject private var datafiles: datafileviewmodel4
    
    init() {
        datafiles = datafileviewmodel4()
    }
    
    var body: some view {
        vstack {
            titleview(title: ["parallel", "(multiple files)"])
            
            button("download all") {
                task {
                    await datafiles.downloadfiles()
                }
            }
            .buttonstyle(bluebuttonstyle())
            .disabled(datafiles.isdownloading)
            
            text("files downloaded: \(datafiles.filecount)")
            
            foreach(datafiles.files) { file in
                hstack(spacing: 10) {
                    text("file \(file.id):")
                    progressview(value: file.progress)
                        .frame(width: 180)
                    text("\((file.progress * 100), specifier: "%0.0f")%")
                    
                    zstack {
                        color.clear
                            .frame(width: 30, height: 30)
                        if file.isdownloading {
                            progressview()
                                .progressviewstyle(circularprogressviewstyle(tint: .blue))
                        }
                    }
                }
            }
            .padding()
            
            spacer().frame(height: 150)
            
            button("reset") {
                datafiles.reset()
            }
            .buttonstyle(bluebuttonstyle())
            
            spacer()
        }
        .padding()
    }
}

结论

在后台执行长期运行的任务并保持ui的响应是很重要的。async/await提供了一个干净的机制来执行异步任务。有的时候，一个方法在后台调用多个方法，默认情况下是按顺序进行这些调用。async 让其立即返回，允许代码进行下一个调用，然后所有返回的对象可以一起等待。这使得多个后台任务可以并行进行。