当同一组中的另一个任务先前失败时，任务组中的任务不会收到取消状态

我发现当任务组中的任何任务因错误而失败时，任务取消状态不会传播。

在我的示例中，两个长时间运行的异步操作同时启动。这1st一个持续3sec并失败了。这2nd一个持续6sec并成功完成。两项任务均检查Task.isCancelled完成前的状态。实际上我看到6s任务没有收到Task.isCancelled state.

我的期望是尽快1st任务失败然后任务组发送cancel组中所有剩余的任务。所以 6 秒任务应该通过检查Task.isCancelled

在长时间运行的异步操作的源代码下面，它通过以下方式模拟长时间运行的执行sleep(). After sleep()它检查Task.isCancelled state:

func runLongOperation(key: String, sleepSec: UInt32, shouldFailWithError: Bool) async throws -> String {
    try await withUnsafeThrowingContinuation { continuation in
        let queue = DispatchQueue(label: "loq")
        queue.async {
            print(" \(key) started...")
            sleep(sleepSec)
            
            if Task.isCancelled {
                print(" ...\(key) Task is cancelled")
            }
                
            if shouldFailWithError {
                print(" ...\(key) finished with failure")
                continuation.resume(throwing: MyError.generic)
            }
            else {
                print(" ...\(key) finished with success")
                continuation.resume(returning: key)
            }
        }
    }
}

此异步函数在任务组中同时执行 2 个长时间运行的操作：

func runTasksGroup() async throws -> [String] {
    return try await withThrowingTaskGroup(of: String.self, body: { group in
        group.addTask {
            return try await self.runLongOperation(key: "#1[3s]", sleepSec: 3, shouldFailWithError: true)
        }
        group.addTask {
            return try await self.runLongOperation(key: "#2[6s]", sleepSec: 6, shouldFailWithError: false)
        }
        
        var strs = [String]()
        for try await str in group {
            strs += [str]
        }
        return strs
    })
}

And runTasksGroup函数从同步开始viewDidLoad()功能

override func viewDidLoad() {
    super.viewDidLoad()
    Task {
        do {
            let strs = try await runTasksGroup()
            print("all done with success \(strs.joined(separator: " "))")
        }
        catch {
            print("some tasks failed")
        }
    }
}

输出

 #1[3s] started...
 #2[6s] started...
 ...#1[3s] finished with failure
 ...#2[6s] finished with success
some tasks failed

持续6秒的任务没有收到Task.isCancelled状态，虽然 3sec 任务之前已经失败了。 谁能解释一下为什么6s任务没有取消？

The sleep in runLongOperation不会响应取消。并且调度到调度队列的块不会自动捕获取消。

• 理想情况下，如果块中的代码可以重构为不异步分派到 GCD 队列，则可以正确处理取消。例如，考虑使用可取消的Task.sleep(nanoseconds:) https://developer.apple.com/documentation/swift/task/sleep(nanoseconds:):

  func runLongOperation(key: String, sleepSec: UInt64, shouldFailWithError: Bool) async throws -> String {
      logger.debug("\(key) started...")
      try await Task.sleep(nanoseconds: sleepSec * NSEC_PER_SEC)
  
      if shouldFailWithError {
          logger.error("\(key) ... finished with failure")
          throw MyError.generic
      } else {
          logger.debug("\(key) ... finished with success")
          return key
      }
  }
  

  或者，如果您想记录取消，则捕获、打印并重新抛出错误：

  func runLongOperation(key: String, sleepSec: UInt64, shouldFailWithError: Bool) async throws -> String {
      do {
          logger.debug("\(key) started...")
          try await Task.sleep(nanoseconds: sleepSec * NSEC_PER_SEC)
  
          if shouldFailWithError {
              logger.error("\(key) ... finished with failure")
              throw MyError.generic
          } else {
              logger.debug("\(key) ... finished with success")
              return key
          }
      } catch {
          logger.error("\(key): \(error.localizedDescription)")
          throw error
      }
  }
  

• 如果您正在使用延续（例如，将调度包装到调度队列内withCheckedThrowingContinuation，如您的示例中所示），您需要手动处理取消。如果您正在包装一些遗留的、可取消的异步流程，您将使用withTaskCancellationHandler。如果您正在循环（例如，进行一些长时间计算），您可以使用以下任一方法手动测试取消状态Task.checkCancellation或定期测试Task.isCancelled. But sleep是不可取消的。

  让我们假设您的任务实际上是一个缓慢、阻塞、不可取消的过程。因此，有一些观察结果：

  1. 使用调度队列会让你脱离可以使用的上下文Task.isCancelled不再了。

  2. 如果可能的话，我鼓励您留在 Swift 并发协作线程池中。即，使用分离任务而不是 GCD。

  3. 您可以使用withTaskCancellationHandler检测取消并更新您自己的状态。

  4. 您将需要同步对该状态变量的访问。要么创建自己的Sendable具有某种同步的状态属性，或者使用参与者。

  例如，下面我正在运行一个缓慢的、不可取消的进程，并执行一个独立的任务：

  func runLongOperation(key: String, sleepSec: UInt32, shouldFailWithError: Bool) async throws -> String {
      let state = State()
  
      return try await withTaskCancellationHandler {
          try await withCheckedThrowingContinuation { continuation in
              Task.detached {
                  print(" \(key) started...")
                  sleep(sleepSec)
  
                  if await state.isCancelled {
                      print(" ...\(key) Task is cancelled")
                      continuation.resume(throwing: CancellationError())
                  } else if shouldFailWithError {
                      print(" ...\(key) finished with failure")
                      continuation.resume(throwing: MyError.generic)
                  } else {
                      print(" ...\(key) finished with success")
                      continuation.resume(returning: key)
                  }
              }
          }
      } onCancel: {
          Task { await state.cancel() }
      }
  }
  

  Where State是线程安全类型：

  actor State {
      private(set) var isCancelled = false
  
      func cancel() {
          isCancelled = true
      }
  }