1.简单介绍一下协程的前世今生
协程（英语：coroutine）马尔文·康威于1958年发明了术语“coroutine”并用于构建汇编程序 ，关于协程最初的出版解说在1963年发表。
协程的概念在60年代就已经提出，目前在服务端中应用比较广泛，在高并发场景下使用极其合适，可以极大降低单机的线程数，提升单机的连接和处理能力，直到近些年随着前端扮演的角色越来越重要，业务越来越复杂，越来越多的回调地狱，让前端代码的可读性越来越差，所以协程才逐渐的展露头脚，比如在WWDC21 推出了Swift 5.5 支持异步编程 \ kotlin\ 以及ES7引入了 async/await。
2、协程的基本概念
协程是一种用户态的轻量级线程，协程的调度完全由用户控制。从技术的角度来说，“协程就是你可以暂停执行的函数”。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。
协程非常类似于线程。但是协程是协作式多任务的，而线程典型是抢占式多任务的。这意味着协程提供并发性而非并行性。
3、演示进程和线程的买票代码，进行性能差异对比。带着问题去思考什么是线程的并发，什么是协程的并发？
非抢占式：
无需系统调用
作为对比，多线程执行一般需要通过系统调用去分配线程进行执行
协程是线程安全的，无需锁
挂起执行时：
保存寄存器和栈
不影响其他协程执行
恢复执行：
恢复之前的寄存器和栈
无缝切换回之前的执行逻辑
协程的优点：
（1）无需线程上下文切换的开销，协程避免了无意义的调度，由此可以提高性能（但也因此，程序员必须自己承担调度的责
任，同时，协程也失去了标准线程使用多CPU的能力）
（2）无需原子操作锁定及同步的开销
（3）方便切换控制流，简化编程模型
（4）高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
协程的缺点：
（进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序。
一、GCD
a、线程之间的切换消耗
真正干活的不是线程，而是CPU。线程越多，干活不一定越快。
b、锁的消耗
线程的管理，线程的管理也是资源的管理，因为多个线程会共享一个进程内的资源。
二、swift 协程
a、await\async
在 WWDC21 中 Swift 盼来了 async/await，作为现代编程语言的标志之一，async/await 可以让我们像编写常规代码一样，轻松地编写异步代码，这样能更直观且更安全地表达我们的思路。async/await 是整个 Swift 结构化并发的基础。
Task.init {
// 插入await关键字之后，调用异步函数work()
await self.work()
}
//在异步函数work()中，出发异步函数 buy()，async 函数可以调用其他 async 函数，也可以直接调用普通的同步函数
func work() async {
let start = CACurrentMediaTime()
for _ in 0 ..< ticketTotal {
let ticket = await self.buy()
print(ticket)
}
let end = CACurrentMediaTime()
print("协程-测量时间：\(end - start)")
}
//Continuation函数会等待异步回调结束。
func buy() async -> Int {
await withUnsafeContinuation { continuation in
self.asynBuyTicket { ticket in
continuation.resume(returning: ticket)
}
}
}
b、actor
Swift 5.5 中的并发模型旨在提供一个安全的编程模型，可以静态检测数据竞争和其他常见的并发错误。结构化并发为函数和闭包提供多线程竞争安全性保障。该模型适用于许多常见的设计模式，包括并行映射和并发回调模式等，但仅限于处理由闭包捕获的状态。
为此 Swift 5.5 引入了新的并发模型 Actor , 它通过数据隔离保护内部的数据，确保在给定时间只有一个线程可以访问该数据。
状态私有：外部无法直接去访问 Actor 的内部数据
只能接收和处理消息：外部想要与 Actor 通信只能发送消息
每个 Actor一次只执行一个消息：Actor 内部在一个消息队列中处理消息，保证了线程安全
actor Ticket {
var number = ticketTotal
var start = CACurrentMediaTime()
var end = CACurrentMediaTime()
func buy() {
if number == ticketTotal {
start = CACurrentMediaTime()
}
if number > 0 {
number -= 1
print((number))
}
if number == 0 {
end = CACurrentMediaTime()
print("actor-测量时间：\(end - start)")
}
}
}
actor 还支持异步属性
struct BundleFile {
let filename: String
var contents: String {
get async throws {
guard let url = Bundle.main.url(forResource: filename, withExtension: nil) else {
throw FileError.missing
}
do {
return try String(contentsOf: url)
} catch {
throw FileError.unreadable
}
}
}
}
c、Continuation
老业务怎么平滑的过渡到async呢？
Swift 5.5 提供了 Continuations 让我们可以把已有的基于闭包的方法转换成 async 方法。
let thread1 = Thread {
Task.init {
let image = try await AsynsData().processImageData()
self.imageView2.image = image
}
}
thread1.start()
let thread2 = Thread {
Task.init {
let image = try await AsynsData().processImageData()
self.imageView3.image = image
}
}
thread2.start()
func processImageData() async throws -> UIImage? {
let upload1 = try await uploadResource()
let upload2 = try await uploadResource()
let upload3 = try await uploadResource()
let downloadImage = try await downloadImage([upload1.data,
upload2.data,
upload3.data])
return downloadImage
}
//图片下载
func downloadImage(_ data:[Data]) async throws -> UIImage {
await withUnsafeContinuation { continuation in
AF.download("https://httpbin.org/image/png").responseData { response in
if let data = response.value, let image = UIImage(data: data) {
continuation.resume(returning: image)
}
}
}
}
//文件上传
func uploadResource() async throws -> (error: APISessionError?, data: Data) {
await withUnsafeContinuation { continuation in
guard let fileUrl = Bundle.main.url(forResource: "symbold", withExtension: "text") else {
continuation.resume(returning:(APISessionError.networkError(error: nil, statusCode: 503), Data()) )
return
}
AF.upload(fileUrl, to: "https://httpbin.org/post").response { response in
if let data = response.data {
continuation.resume(returning:(nil, data))
} else {
continuation.resume(returning:(.noData, Data()))
}
}
}
}