# 2.1 任务


# 任务的创建

在前面的章节中，我们已经使用过 `Task` 了，比如在同步环境 `viewDidLoad` 方法中开启异步环境，或者使用 View 的 `.task` 修饰器开启异步任务。还有 `async let` 这样的语法糖，也会隐式地创建 task，方便我们写出简洁、安全的并发代码。

相比 `async let` 的隐式创建，`Task` 则需要显式创建，它也给我们提供了更多的操作空间，比如指定任务的优先级，手动取消任务，在函数之间传递任务实例等。

`Task` 的定义如下：

```swift
struct Task<Success, Failure> where Success : Sendable, Failure : Error
```

它是一个泛型的结构体， 有两个初始化方法：

```swift
// Available when Failure is Never.
@discardableResult init(priority: TaskPriority? = nil, operation: @escaping @Sendable () async -> Success)

// Available when Failure is Error.
@discardableResult init(priority: TaskPriority? = nil, operation: @escaping @Sendable () async throws -> Success)
```

- priority：任务的优先级，默认由系统分配可用的最高优先级。
- operation：提供异步环境的闭包。

这两个方法大同小异，唯一的区别在于第二个方法是可以抛出错误的。Task 实例有个属性 `value`，当我们需要返回异步结果时，会用到这个值。对应上面两个初始化方法，它的定义也有细微差别，后文会示范其用法。

```swift
var value: Success { get async }

var value: Success { get async throws }
```

`Task` 还遵循三个协议：`Equatable`、`Hashable`、`Sendable`，前两个协议我们非常熟悉，据此我们可以对 Task 实例使用 `==` 和 `!=` 进行判等操作。而 [Sendable](https://developer.apple.com/documentation/swift/sendable) 是 iOS 15 新增的重要协议，该协议没有任何属性和方法，但是 Swift 标准库中大量的类和数据类型都遵循了该协议。在 `Task` 的结构体定义中，我们也看到了 `Sendable` 的身影，初始化方法中还出现了属性包装器 `@Sendable` 。`Sendable` 的作用是什么？

# Sendable 协议、@Sendable 属性

并发安全需要解决的一大问题就是数据竞争，问题一旦出现，则难以排查。而 `Sendable` 帮我们把问题抛出的时机提前至编译层面，有它出现的地方，就表明遵循该协议的数据是可以在多线程之间安全传递的。如果编译器遇到了 `Sendable` 而我们的代码又存在潜在的安全问题，编译器就会发出警告。

`Sendable` 协议的约束有助于我们避开安全隐患，Swift 中常见的类型都已经支持该协议：

- String、Int 等基础数据类型。
- 包含数据都为值类型的可选类型/集合/元组
- 元类，比如 String.self 等。

对于其它数据类型，有如下规则：

- 结构体和枚举，如果其属性均已实现该协议，它们会自动实现该协议
- class 类型不能支持继承，而且所有属性都必须是实现该协议的不可变数据。
- actor 类型默认已实现该协议。
- 闭包只能捕获实现该协议的不可变数据。

actor 类型后面会单独介绍，它通过状态隔离和同步机制保证了数据的安全性，这里不展开来讲，这里着重举例说明与一下 class 和闭包的使用注意事项。

我们现在有如下声明的 Cat 类：

```swift
final class Cat: Sendable {
  let name: String
  
  init(name: String) {
    self.name = name
  }
}
```

1. 如果 `let` 改为 `var`，编译器会告警。因为 class 是引用类型，`var` 变量可能会被多个线程读写，这会导致数据竞争问题。
2. `final` 关键词是必须的，否则无法通过编译，以防继承和重写带来的线程安全问题。

结构体、枚举等数据类型可以通过 `Sendable` 协议的约束来保证数据在传递过程中安全性。但函数/闭包可以跨并发域传递却无法使用协议来约束，因此 Swift 引入了 `@Sendable` 属性包装器来修饰函数/闭包，它向编译器宣告，函数/闭包内捕获的值都是线程安全的。

如下示例代码中的 closure 使用了 `@Sendable` 修饰，但我们在 test 函数中，task 闭包内捕获了 cat 变量，这是无法通过编译的，将 cat 声明为常量即可。

```swift
func task(_ closure: @escaping @Sendable () async -> ()) async {
  await closure()
}

func test() async {
  var cat = Cat(name: "BiuBiu")
  await task {
    print(cat.name)
  }
}
```

# 任务的优先级

系统提供如下优先级（由高至低），后面的数字是打印 `Task.currentPriority.rawValue` 获取到的值。

```swift
public static let high: TaskPriority // 25

public static let userInitiated: TaskPriority // 25

public static var medium: TaskPriority { get } // 21

public static let low: TaskPriority // 17

public static let utility: TaskPriority // 17

public static let background: TaskPriority // 9
```

如果创建子任务时没有指定优先级，它会自动继承父任务的优先级，`Task.detached {}` 创建的分离式任务除外。

# 任务的协同式取消、错误处理

`Task` 提供了一个静态方法 `sleep(nanoseconds:)` ，它能使当前任务进入睡眠，时长大于等于指定数值。这里的时长并非一个精确值，因为在达到指定时长后，系统可能正在处理其它任务而无暇继续当前任务，所以睡眠时长可能会大于指定数值。

系统提供的入参单位是纳秒，书写不便，通过如下扩展方法可以传入以秒为单位的参数：

```swift
extension Task where Success == Never, Failure == Never {
  static func sleep(seconds: Double) async throws {
    try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
  }
}
```

`Task.sleep` 是不同于 `Thread.sleep` 的，后者会阻塞线程，达到睡眠时间后，代码会在同一条线程继续执行。而 `Task.sleep` 只是挂起当前任务，其它的任务仍然可以继续运行，达到睡眠时间后，任务可能在另一个线程唤醒并继续执行。

比如下面的示例代码，间隔 2 秒打印出来的可能是同一条线程，也可能在不同线程。

```swift
Task {
  printLog(Thread.current)
  try? await Task.sleep(seconds: 2)
  printLog(Thread.current)
}
```

上面的示例里我们使用了 `try`，是因为任务在睡眠期间可能会被提前取消，此时任务会抛出 `Task.CancellationError` 类型的错误。比如下面的示例代码，任务在睡眠期间被取消了，因此无法得到返回的 `value`，控制台会直接抛出错误。如果我们将 `task.cancel()` 这行代码注释，在 2 秒后控制台会打印返回的 `value` 值。

```swift
func cancelSleepTask() async {
  let task = Task { () -> String in
    try await Task.sleep(seconds: 2)
    return "Time is out!"
  }
  
  task.cancel()
  
  do {
    let res = try await task.value
    printLog(res)
  } catch {
    printLog(error)
  }
}
```

当我们调用 Task 的实例方法 `cancel()` 时，任务实际上并不是立即取消，它只是将任务标记为取消状态，但它仍可能继续完成任务。任务是否真正地被取消，这取决于我们是否显式地取消该任务。Task 提供了两个静态方法：`isCacelled` 和 `checkCancellation()` 供我们使用，我们可以在合适的时机取消任务。

但是在上面的示例代码中，我们并没有显式地取消任务，只是调用了 `cancel()` 方法，为什么就立即抛出错误了呢？这是是因为 `Task.sleep` 隐式地实现了 `checkCancellation()` 。

下面的示例代码表示在一个父任务中开启了两个子任务，两个子任务分别在等待 2、4 秒后返回一个字符串，父任务在等待子任务完成后，返回一个字符串数组。

```swift
func coopCancelTask() async {
  let task = Task { () -> [String] in
    // 1
    let task1 = Task { () -> String in
      try await Task.sleep(seconds: 2)
      let res = "Task 1 is Done!"
      printLog(res)
      return res
    }
    // 2
    let task2 = Task { () -> String in
      try await Task.sleep(seconds: 4)
      let res = "Task 2 is Done!"
      printLog(res)
      return res
    }
    // 3
    return try await [task1.value, task2.value]
  }
  
  task.cancel()
  
  do {
    let res = try await task.value
    printLog(res)
  } catch {
    printLog(error)
  }
}
```

控制台会打印如下：

```
// after 2 seconds
"Task 1 is Done1"

// after 4 seconds
"Task 1 is Done1"
["Task 1 is Done1", "Task 2 is Done1"]
```

我们在 // 1 这里插入如下代码：

```swift
try Task.checkCancellation()
```

这行代码表示任务会在这里检查其是否取消，如果是，则会抛出错误，不再继续执行。重新运行程序，结果符合预期，控制台直接抛出了错误，task1 和 task2 并没有执行。

我们移动上面的代码至 // 2 处，控制台会先抛出 task 的错误，2 秒后打印 "Task 1 is Done!"。同理，将其移动至 // 3 处，控制台先抛出错误，然后在 2、4 秒处分别打印 task1、task2 返回的值。

上面的例子中，父任务调用 `cancel()` 方法时，它只是将 `Task.isCancelled` 标记为 true。如果子任务没有显式或隐式地检查父任务的取消行为，子任务依然会继续执行，父任务依然会等待所有子任务执行完毕。如果 `Task.checkcancellation` 的调用时机在子任务开始运行之后，子任务还是会继续执行，但父任务会抛出错误，子任务执行的结果会被忽略。

我们移除刚才插入的代码，在 // 3 处插入代码：
```swift
if Task.isCancelled { return ["Nothing"] }
```

这一次打印如下：

```
["Nothing"]

// after 2 seconds
"Task 1 is Done!"

// after 4 seconds
"Task 2 is Done!"
```

由于我们调用了 `cancel()` 方法，因此 `Task.isCancelled`  的值为 true，所以 task 会直接返回我们给定的默认值（["Nothing"]）。但是在判定 `Task.isCancelled` 之前，task 在自检时并没有被告知要取消任务，所以 task1、task2 仍然执行了。试试将这行代码放在 // 1 处，控制台会直接打印 task 返回的 ["Nothing"]，后面的 task1、task2 并不会执行。

讲了这么多，其实只是为了表达一个核心概念：任务的取消行为不是单一动作，而是协同式的。当我们 `cancel()` 某个任务时，它并不是真正地取消了，只是给 isCancelled 做了个标记。任务是否真正地取消，取决于 `Task.checkCancellation`、`Task.isCancelled` 或 `task.isCancelled` 的调用时机及逻辑处理。

如果我们只是为了取消任务并抛出错误，使用 `Task.checkCancellation` 即可，系统会取消任务并自动抛出错误。如果我们需要做更复杂的逻辑处理，比如返回默认值、忽略错误或是抛出自定义错误等，`Task.isCancelled` 则给予了我们更多的操作空间。

Concurrency 的设计宗旨是让我们使用简洁易读的代码写出高效，安全的代码，实现复杂的并发需求。那么，它为什么不让系统自主处理并发任务的取消行为，而是让我们自己去显式处理呢？因为系统可能正在处理复杂的 I/O 操作或调用耗时的网络请求等，在任务进行的过程中，如果我们任由系统立即 `cancel()` 该任务，系统反而需要花更多的资源去“恢复现场”，甚至可能引发意想不到的错误，这大大地增加了事情的复杂性。所以，我们在合适的时机显式地取消任务，让被取消的任务享有“知情权”，实际上在为系统减负，同时也让我们的代码变得更加清晰可控。

前文我们提到过，`.task` 修饰器会在 View 视图销毁时取消任务，这是因为系统为我们隐式地实现了 `Task.checkCancellation()` ，我们无需手动取消该任务。还有 `Task.sleep` 、 `URLSession` 默认都是支持协同式取消机制的。

任务取消行为的协同式机制，从狭义上看，它是指系统任务之间的信息共享及协同行为。从广义上看，它还包括了人和系统的协同工作。无论是系统还是人为的工作，目的都是为了安全地取消任务，同时避免系统资源的浪费和有效回收系统资源。综上，当我们处理复杂耗时的并发任务时，需要将协同式取消机制常挂于心。






---

> 作者: 宋明  
> URL: https://apolla.cc/posts/2.1-%E4%BB%BB%E5%8A%A1/  

