采用 Swift 并发

采用 Swift 并发

与我们一起了解 Swift 并发方面的核心概念。并发可帮助你提高 App 的响应速度和性能，而 Swift 旨在让正确编写异步和并发代码变得更加简单。我们会介绍将 App 编程从单线程转换为并发流程所需的步骤。无论你想让代码更加异步化、将代码移到后台，还是在并发任务中共享数据，我们都将帮助你确定充分利用 Swift 并发功能的恰当方式和时机。

章节
- 0:00 - 简介
- 3:17 - 单线程代码
- 6:00 - 异步任务
- 7:24 - 交错执行
- 10:22 - 并发简介
- 11:07 - 并发函数
- 13:10 - 非限定代码
- 14:13 - 并发线程池
- 14:58 - 共享数据
- 15:49 - 值类型
- 17:16 - Actor 限定类型
- 18:30 - 类
- 23:18 - Actor
- 26:12 - 总结
资源
相关视频

WWDC25
- 跟着视频学编程：使用 Swift 并发机制提升 App 性能
WWDC23
- 超越结构化并发的基础
大家好！我是 Swift 团队的 Doug 很高兴能和大家探讨如何在 App 中充分发挥 Swift 并发功能的优势并发编程能让代码同时执行多个任务比如当 App 需要从磁盘读取文件或发起网络请求等待数据返回时使用并发可以显著提升响应速度同样在处理大型图像等任务时也能通过并发将繁重运算转移到后台执行 Swift 的并发模型经过精心设计让并发代码更容易正确编写它通过显式标记并发上下文明确标识跨任务共享的数据并利用这些信息在编译阶段就能检测潜在的数据争用问题因此你可以按需引入并发机制而无需担心产生难以修复的数据争用
大多 App 只需在特定场景使用并发有些甚至完全不需要由于并发代码比单线程代码更复杂建议只在需要时引入并发
App 初始阶段完全可以在主线程运行所有代码事实上很多功能仅靠单线程就能完美实现主线程是处理 UI 事件和更新用户界面的核心线程如果你的 App 没有大量计算需求保持单线程架构是完全可行的方案！最终你可能需要引入异步代码比如从网络获取内容时你的代码可以等待网络传输内容而不会导致用户界面卡顿如果这些任务运行时间过长我们可以将它们转移到后台线程与主线程并行处理
当 App 继续演进时可能会发现将所有数据都放在主线程处理会导致性能下降这时就可以针对特定场景引入专为后台运行设计的数据类型
Swift 并发编程提供了 Actor 和 Task 等工具专门用于实现这类并发操作大型 App 的架构最终可能会演变成这样但并非从一开始就要构建复杂架构也不是所有 App 都需要走到这一步本次讲座将逐步演示如何将 App 从单线程演进到并发架构在每个演进阶段我们会帮助你判断时机、讲解对应的 Swift 语言特性、演示高效使用方法并解析底层工作原理首先解析单线程代码在 Swift 并发模型中的运行机制然后引入异步任务处理高延迟操作如网络访问接着通过并发机制将任务移至后台线程并学习如何在不引入数据争用的情况下跨线程共享数据最后我们将使用 Actor 将数据完全移出主线程现在让我们从单线程代码开始运行程序时代码开始在主线程运行除非你显式引入并发机制在其他地方运行代码否则新增代码会始终在主线程执行单线程代码的编写和维护更为简单因为同一时间只会执行一个操作即便后续引入并发机制 Swift 也会为主线程代码提供保护
主线程及它的所有数据都由主 Actor 表示由于主线程只有一个主 Actor 内部不存在并发问题可以使用 @MainActor 标注来指定数据或代码必须在主 Actor 上运行 Swift 会确保主 Actor 代码仅在主线程执行并且主 Actor 数据只能在主线程被访问这类代码被称为隔离于主 Actor Swift 默认使用主 Actor 来保护主线程代码这就像 Swift 编译器自动为模块中的所有代码都加上了 @MainActor 因此我们可以像访问静态变量一样自由地在任何地方访问共享状态在主 Actor 模式下只要不主动引入并发就无需考虑并发访问的问题默认使用主 Actor 保护代码的功能是由构建设置驱动的这主要适用于你的主 App 模块以及所有专注于 UI 交互的模块在 Xcode 26 创建的新 App 项目中这一模式默认启用在本讲座中我们将假设所有代码示例都启用了主 Actor 模式
现在让我们为图像模型添加一个方法用于从 URL 获取并显示图像我们需要从本地文件载入图像然后解码并在 UI 中显示我们的 App 完全不涉及并发处理所有工作都由单一的主线程完成整个函数在主线程上连续运行只要其中每个操作都足够快速就不会有问题
目前我们仅支持从本地读取文件若要让 App 能够通过网络获取图像我们就需要使用不同的 API
这个 URLSession API 可以根据给定的 URL 从网络获取数据但如果在主线程上运行这个方法在数据下载完成前用户界面都会处于卡顿状态作为开发人员保持 App 的响应能力至关重要这意味着要避免长时间占用主线程导致 UI 出现卡顿或假死现象 Swift 并发机制提供了解决方案：在等待网络请求等数据时可以使用异步任务来避免阻塞主线程为了防止这类卡顿问题网络访问本就是异步执行的我们可以将 fetchAndDisplayImage 方法改造为支持异步调用只需将函数标记为‘async’并使用 ‘await’调用 URL session API await 标明了函数可能被挂起的位置这意味着在当前线程上停止执行直到等待的事件完成函数才能恢复运行
我们可以理解为将函数拆分为两部分：第一部分执行到开始获取图像为止第二部分则在图像获取完成后继续执行通过这种方式拆分函数我们允许其他任务在这两部分之间运行从而保持 UI 的响应性
实际上许多库 API 如 URLSession 会将任务分配到后台执行我们仍未在代码中引入并发因为根本不需要！我们只是通过将部分代码设为异步并调用能自动分配任务的库 API 就提升了应用程序的响应性能在代码层面我们唯一需要做的就是采用 async/await 语法
到目前为止我们的代码仅运行单个异步函数每个异步函数都在一个任务中执行任务是独立于其他代码的执行单元应当被设计为完成从开始到结束的特定操作通常我们会基于按钮点击等事件来创建任务在这里任务负责完成完整的 “获取-显示图像”操作一个 App 可以包含多个异步任务除了我们讨论的 “获取-显示图像”任务外这里我还添加了第二个任务即先获取新闻数据并显示然后等待刷新操作每个任务都会按顺序从头到尾执行它的操作流程虽然数据获取在后台进行但每个任务中的其他操作都会在主线程运行且同一时间只能执行一个操作由于任务之间相互独立它们可以轮流占用主线程资源主线程会根据任务就绪状态依次执行各个任务的对应操作片段这种让单个线程在多个任务间交替执行的机制称为“交错” 它通过最大化利用系统资源来提升整体性能线程可以尽快开始处理任意任务避免在等待单个操作时处于闲置状态若图像获取比新闻获取先完成主线程就会优先执行图像解码与显示再显示新闻反之若新闻数据先到位主线程则会先展示新闻再解码图像
当你的 App 需要同时执行多个独立操作时并行异步任务会非常高效当操作需要严格按特定顺序执行时则应将这些操作放在同一个任务中
对于网络请求等高延迟操作使用异步任务能隐藏等待时间从而确保 App 始终保持响应性在这方面一些库能提供帮助它们通过异步 API 代表你处理并发操作而你自己的代码仍可保持在主线程运行 URLSession API 已经在后台线程处理网络请求为我们引入了并发机制而我们的“获取-显示图像” 操作仍运行在主线程我们可能会发现图像解码耗时过长比如处理大图时出现 UI 卡顿
单线程异步模式通常已能满足 App 需求但当主线程负载过重导致 App 没有响应时就需要借助 Instruments 等性能分析工具定位耗时瓶颈若某项工作无需引入并发即可优化则应优先采用单线程方案当性能已达瓶颈时才需要考虑引入并发机制并发允许代码在后台线程与主线程并行执行既能避免阻塞 UI 又能通过利用系统多核 CPU 提升处理效率我们的目标是将解码任务移出主线程转由后台线程处理由于当前处于主 Actor 默认模式 fetchAndDisplayImage 和 decodeImage 都被隔离在主 Actor 中主 Actor 代码可以自由访问仅限主线程的所有数据和代码这种安全性正是源于主线程不存在并发冲突
我们可以通过给 decodeImage 函数添加 @concurrent 属性来将它移至后台执行 @concurrent 会指示 Swift 在后台线程运行这个函数但改变执行位置的同时也改变了我们对 decodeImage 所能访问的状态的假设让我们看看具体实现当前实现会检查存储在主 Actor 中的图像缓存字典这种操作本应仅在主线程安全执行 Swift 编译器会精准指出函数试图访问主 Actor 数据的代码位置这正是我们在引入并发时避免引入错误所需的关键信息要安全地引入并发机制有几种策略可以解除与主 Actor 的绑定关系在某些情况下可以将主 Actor 代码移至始终在主 Actor 上运行的调用方中若需要确保操作同步执行这是种理想的策略或者可以通过 await 从并发代码中异步访问主 Actor
若代码完全无需依赖主 Actor 则可添加 nonisolated 关键字将它与任何 Actor 分开现在我们先探讨第一种策略其他方法后面再讨论我打算将图像缓存逻辑移至运行在主 Actor 的 fetchAndDisplayImage 中在发起异步调用前检查缓存能有效消除延迟若图像已缓存 fetchAndDisplayImage 将完全同步执行且不会挂起这意味着结果可立即交付至 UI 仅当图像未缓存时才会触发挂起
此外由于不再需要我们可以移除 decodeImage 中的 url 参数现在我们只需等待 decodeImage 的结果即可
@concurrent 函数总是会从 Actor 中切换出来运行若希望函数保持在调用方的 Actor 上运行可以使用 nonisolated 关键字 Swift 还提供了更多引入并发的方式详见“超越结构化并发的基础”
如果我们要将解码 API 作为供多客户端使用的库函数采用 @concurrent 并非总是最佳的 API 选择解码耗时取决于数据量大小对于小型数据完全可以在主线程安全处理对于库最好提供非隔离的 API 让客户端自行决定是否卸载任务
非隔离代码非常灵活因为它可以从任何上下文中调用：如果你在主 Actor 上调用它它会保持在主 Actor 上执行如果你从后台线程调用它它就保留在后台线程上这种特性使它成为通用库的理想默认选择当工作被调度至后台时系统会自动分配后台线程执行任务并发线程池包含系统所有后台线程数量可动态调整在 Watch 等小型设备上并发线程池可能只有 1-2 个线程而多核系统则拥有更多后台线程任务运行在哪个后台线程并不重要系统会自动优化资源分配例如当任务挂起时原线程会立即执行其他就绪任务当任务恢复时则可能被调度到线程池中的任意可用线程这些线程可能与初始线程不同
引入并发机制后我们需要在不同线程间共享数据但众所周知在并发代码中共享可变状态极易引发难以调试的运行时错误 Swift 可以帮助你在编译时发现这些错误让你安全地编写并发代码每次在主 Actor 与并发线程池间切换时都会涉及跨线程数据共享当从 UI 获取 URL 时它会从主 Actor 传递到后台线程以获取图像获取的图像数据随后被传递给解码环节解码完成后再将图像与 self 一起传回主 Actor Swift 会确保所有这些值在并发代码中的访问安全性假设 UI 更新触发了涉及这个 URL 的额外任务会发生什么情况幸运的是 URL 作为值类型当被拷贝到后台线程时后台线程获得的是独立于主线程的副本如果用户通过 UI 输入了新 URL 主线程代码可以自由使用或修改副本并且这些更改不会影响后台线程使用的值这意味着共享 URL 等值类型是安全的因为实际上并不存在真正的共享：每个副本都完全独立
值类型从一开始就是 Swift 的重要特性所有基础类型如字符串、整数、日期都是值类型
包含值类型的集合如字典、数组同样如此存储值类型的结构体和枚举如这个 Post 结构体也不例外我们将可安全并发共享的类型称为 Sendable 类型 Sendable 是一个协议任何符合这个协议的类型都能安全共享像 Array 这样的集合类型对 Sendable 有条件遵循只有当它们的元素为 Sendable 时集合本身才是 Sendable 当结构体和枚举的所有实例数据都符合 Sendable 时它们也可以被标记为 Sendable 而主 Actor 类型隐式符合 Sendable 无需显式声明 Actor 如主 Actor 通过确保每次只能被一个任务访问来保护非 Sendable 状态的安全 Actor 可能存储传入方法的数值也可能从它的方法返回受保护状态的引用当值类型传入或传出 Actor 时 Swift 编译器会检查这个值是否可安全用于并发代码让我们重点了解一下 decodeImage 的异步调用
decodeImage 作为实例方法它会隐式传递 self 参数
这里涉及两个值被传出主 Actor 以及一个结果值被传回主 Actor 的情况 “self”作为主 Actor 隔离的图像模型类实例主 Actor 会保护可变状态使得向后台线程传递类引用是安全的而 Data 作为值类型天然符合 Sendable
关键在于图像类型它可能是类似 Data 的值类型自然符合 Sendable 但我们现在要讨论的是像类这样不符合 Sendable 的类型类属于引用类型当将一个变量赋值给另一个变量时它们指向内存中的同一对象当通过某个变量修改对象时例如缩放图像所有指向同一对象的变量都会立即看到这些变化虽然 fetchAndDisplayImage 并未并发使用图像值但 decodeImage 在后台运行时无法访问任何受 Actor 保护的状态它仅从给定数据创建新的图像实例由于这个图像不会被任何并发代码引用因此可安全传回主 Actor 并显示在 UI 中让我们看看引入并发后的情况首先 scaleAndDisplay 方法在主线程加载新图像 Image 变量指向包含猫图片的对象接着函数在并发线程池创建任务这个任务获取图像的副本最后主线程继续执行图像显示此时问题显现后台线程正在修改图像：调整宽高比并将像素替换为缩放后的版本而主线程却仍基于旧尺寸遍历像素这就形成了数据争用这可能导致 UI 显示异常更常见的是当程序尝试访问像素数组边界外的内容时引发崩溃当代码尝试共享非 Sendable 类型时 Swift 并发机制会通过编译器错误来预防数据争用本例中编译器正提示并发任务在捕获 image 对象而这个对象同时被主 Actor 用于图像显示要修正这个问题我们必须确保避免并发共享同一对象若要在 UI 中呈现图像特效正确的解决方案是等待缩放完成后再显示图像我们可以将所有三个操作移至同一任务中以确保顺序执行由于 displayImage 必须在主 Actor 上运行我们需要通过 await 从并发任务中调用它如果直接将 scaleAndDisplay 改为异步方法还能进一步简化代码无需新建任务直接在调用 scaleAndDisplay 的任务中按顺序执行这三个操作当我们将图像传至主 Actor 进行 UI 展示后主 Actor 可以自由存储对图像的引用例如缓存图像对象若试图在图像显示在 UI 后再次修改编译器会抛出非安全并发访问错误解决方案是在图像传送至主 Actor 前完成所有修改若使用类作为数据模型这些模型类通常初始运行于主 Actor 以便部分数据可展示在 UI 中当最终决定需要在后台线程操作时可将它标记为 nonisolated 但通常不应使它们符合 Sendable 因为你不会希望模型的部分数据在主线程更新而另一部分在后台线程更新保持模型类的非 Sendable 特性可预防这类并发修改同时也更简便因为使类符合 Sendable 通常需要采用锁等底层同步机制与类一样闭包也可能创建共享状态这里有一个类似之前缩放显示图像功能的函数它先创建图像对象然后调用 perform(afterDelay:) 并传入一个用于缩放图像的闭包这个闭包持有对同一图像的另一个引用我们称之为对图像变量的捕获与非 Sendable 类相同只要不被并发调用具有共享状态的闭包仍是安全的仅当需要并发共享时才应将函数类型标记为 Sendable
每当数据在 Actor 与任务间传递时都会触发 Sendable 检查这是为了防止数据争用导致 App 出现错误许多常见类型都符合 Sendable 可安全用于并发任务间共享而类和闭包可能包含非安全共享的可变状态因此应确保每次仅被单一任务使用
你仍可将对象在任务间传递但务必在传递前完成所有修改操作将异步任务移至后台线程能释放主线程确保 App 响应流畅若发现主 Actor 上存储过多数据导致异步任务需要频繁 “上报”主线程此时可以引入更多 Actor
随着 App 演进主 Actor 承载的状态可能不断增长例如新增网络访问管理等子系统后网络管理器维护的开放连接集合等状态都会驻留主 Actor 每次网络数据获取都需要访问这些状态当我们开始使用这些额外的子系统时先前的“获取-显示图像”任务变得复杂：虽然尝试在后台线程运行却不得不跳转到主线程因为于网络管理器的数据必须通过主线程访问最终可能导致多个任务同时争抢主 Actor 执行权限虽然单个操作可能很快但当大量任务频繁跳转时仍会导致 UI 卡顿之前我们通过将代码封装到 @concurrent 函数中成功将它移出主线程但当前瓶颈在于访问网络管理器数据为此可以引入专属的网络管理器 Actor 和主 Actor 一样 Actor 也会隔离自己的数据因此只有在这个 Actor 上运行时才能访问这些数据除了主 Actor 你还可以自定义 Actor 类型这类类型类似于主 Actor 类它们隔离数据确保同一时间只有一个线程能访问同时作为 Sendable 类型 Actor 对象可安全共享但与主 Actor 不同程序中可存在多个独立 Actor 实例且它们不像主 Actor 那样绑定到单个线程因此将部分状态从主 Actor 迁移至 Actor 对象可以让更多代码在后台线程执行从而保持主线程畅通确保 UI 响应流畅
当主 Actor 存储的数据导致过多代码运行在主线程时就应使用 Actor 这时你可以将非 UI 部分代码如网络管理模块的数据分离到新 Actor 中
但需注意 App 中大多数类并不适合作为 Actor 面向 UI 的类应保持在主 Actor 以便直接与 UI 状态交互模型类通常也应驻留主 Actor 与 UI 交互或保持非 Sendable 以避免引发对模型的大量并发访问本次分享从单线程代码开始随着需求增长我们引入了异步任务来隐藏延迟采用并发代码在后台线程运行并通过 Actor 将数据访问移出主线程事实上多数 App 都会遵循类似的演进路径
使用性能分析工具来确定何时以及将哪些代码移出主线程 Swift 并发机制将帮助你正确地将这些代码与主线程分离从而提高 App 的性能和响应速度
我们为你的 App 提供了一些推荐的构建设置来协助引入并发 “渐进式并发”设置启用了一系列即将推出的功能使并发编程更加容易建议所有项目都采用这个设置对于主要与 UI 交互的 Swift 模块比如你的主 App 模块我们还建议将默认 Actor 隔离设置为“主 Actor” 这样除非你另有说明否则代码将在主 Actor 上运行这些设置共同作用使单线程 App 更易于编写并在需要时为引入并发提供更便捷的路径 Swift 并发是一种旨在帮助改进 App 的工具当你发现 App 存在性能问题时可以用它来引入异步或并发代码 Swift 6 迁移指南可以帮助解答更多关于并发和数据争用安全实现路径的疑问要了解如何将本次讲座中的概念应用于示例 App 请观看我们“跟着视频学编程”的配套讲座谢谢

var greeting = "Hello, World!"

func readArguments() { }

func greet() {
  print(greeting)
}

readArguments()
greet()

4:13 - Data types in a the app

struct Image {
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
}

final class Library {
  static let shared: Library = Library()
}

4:57 - Load and display a local image

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) throws {
    let data = try Data(contentsOf: url)
    let image = decodeImage(data)
    view.displayImage(image)
  }

  func decodeImage(_ data: Data) -> Image {
    Image()
  }
}

final class Library {
  static let shared: Library = Library()
}

5:36 - Fetch and display an image over the network

import Foundation

struct Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) throws {
    let (data, _) = try URLSession.shared.data(from: url)
    let image = decodeImage(data)
    view.displayImage(image)
  }

  func decodeImage(_ data: Data) -> Image {
    Image()
  }
}

final class Library {
  static let shared: Library = Library()
}

6:10 - Fetch and display image over the network asynchronously

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = decodeImage(data)
    view.displayImage(image)
  }

  func decodeImage(_ data: Data) -> Image {
    Image()
  }
}

final class Library {
  static let shared: Library = Library()
}

7:31 - Creating a task to perform asynchronous work

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()
  var url: URL = URL("https://swift.org")!

  func onTapEvent() {
    Task {
      do {
	try await fetchAndDisplayImage(url: url)
      } catch let error {
        displayError(error)
      }
    }
  }

  func displayError(_ error: any Error) {
  }

  func fetchAndDisplayImage(url: URL) async throws {
  }
}

final class Library {
  static let shared: Library = Library()
}

9:15 - Ordered operations in a task

import Foundation

class Image {
  func applyImageEffect() async { }
}

final class ImageModel {
  func displayImage(_ image: Image) {
  }

  func loadImage() async -> Image {
    Image()
  }
  
  func onButtonTap() {
    Task {
      let image = await loadImage()
      await image.applyImageEffect()
      displayImage(image)
    }
  }
}

9:38 - Fetch and display image over the network asynchronously

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = decodeImage(data)
    view.displayImage(image)
  }

  func decodeImage(_ data: Data) -> Image {
    Image()
  }
}

10:40 - Fetch and display image over the network asynchronously

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = decodeImage(data, at: url)
    view.displayImage(image)
  }

  func decodeImage(_ data: Data, at url: URL) -> Image {
    Image()
  }
}

11:11 - Fetch over network asynchronously and decode concurrently

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = await decodeImage(data, at: url)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data, at url: URL) async -> Image {
    Image()
  }
}

11:30 - Implementation of decodeImage

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var cachedImage: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = await decodeImage(data, at: url)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data, at url: URL) async -> Image {
    if let image = cachedImage[url] {
      return image
    }

    // decode image
    let image = Image()
    cachedImage[url] = image
    return image
  }
}

12:37 - Correct implementation of fetchAndDisplayImage with caching and concurrency

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var cachedImage: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    if let image = cachedImage[url] {
      view.displayImage(image)
      return
    }

    let (data, _) = try await URLSession.shared.data(from: url)
    let image = await decodeImage(data)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data) async -> Image {
    // decode image
    Image()
  }
}

13:30 - JSONDecoder API should be non isolated

// Foundation
import Foundation

nonisolated
public class JSONDecoder {
  public func decode<T: Decodable>(_ type: T.Type, from data: Data) -> T {
    fatalError("not implemented")
  }
}

15:18 - Fetch over network asynchronously and decode concurrently

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = await decodeImage(data, at: url)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data, at url: URL) async -> Image {
    Image()
  }
}

16:30 - Example of value types

// Value types are common in Swift
import Foundation

struct Post {
  var author: String
  var title: String
  var date: Date
  var categories: [String]
}

16:56 - Sendable value types

import Foundation

// Value types are Sendable
extension URL: Sendable {}

// Collections of Sendable elements
extension Array: Sendable where Element: Sendable {}

// Structs and enums with Sendable storage
struct ImageRequest: Sendable {
  var url: URL
}

// Main-actor types are implicitly Sendable
@MainActor class ImageModel {}

17:25 - Fetch over network asynchronously and decode concurrently

import Foundation

class Image {
}

final class View {
  func displayImage(_ image: Image) {
  }
}

final class ImageModel {
  var imageCache: [URL: Image] = [:]
  let view = View()

  func fetchAndDisplayImage(url: URL) async throws {
    let (data, _) = try await URLSession.shared.data(from: url)
    let image = await self.decodeImage(data, at: url)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data, at url: URL) async -> Image {
    Image()
  }
}

18:34 - MyImage class with reference semantics

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scale(by factor: Double) {
  }
}

let image = MyImage()
let otherImage = image // refers to the same object as 'image'
image.scale(by: 0.5)   // also changes otherImage!

19:19 - Concurrently scaling while displaying an image is a data race

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scaleImage(by factor: Double) {
  }
}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()

  // Slide content start
  func scaleAndDisplay(imageName: String) {
    let image = loadImage(imageName)
    Task { @concurrent in
      image.scaleImage(by: 0.5)
    }

    view.displayImage(image)
  }
  // Slide content end

  func loadImage(_ imageName: String) -> MyImage {
    // decode image
    return MyImage()
  }
}

20:38 - Scaling and then displaying an image eliminates the data race

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scaleImage(by factor: Double) {
  }
}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()

  func scaleAndDisplay(imageName: String) {
    Task { @concurrent in
      let image = loadImage(imageName)
      image.scaleImage(by: 0.5)
      await view.displayImage(image)
    }
  }

  nonisolated
  func loadImage(_ imageName: String) -> MyImage {
    // decode image
    return MyImage()
  }
}

20:54 - Scaling and then displaying an image within a concurrent asynchronous function

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scaleImage(by factor: Double) {
  }
}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()

  @concurrent
  func scaleAndDisplay(imageName: String) async {
    let image = loadImage(imageName)
    image.scaleImage(by: 0.5)
    await view.displayImage(image)
  }

  nonisolated
  func loadImage(_ imageName: String) -> MyImage {
    // decode image
    return MyImage()
  }
}

21:11 - Scaling, then displaying and concurrently modifying an image is a data race

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scaleImage(by factor: Double) {
  }

  func applyAnotherEffect() {
  }
}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()

  // Slide content start
  @concurrent
  func scaleAndDisplay(imageName: String) async {
    let image = loadImage(imageName)
    image.scaleImage(by: 0.5)
    await view.displayImage(image)
    image.applyAnotherEffect()
  }
  // Slide content end

  nonisolated
  func loadImage(_ imageName: String) -> MyImage {
    // decode image
    return MyImage()
  }
}

21:20 - Applying image transforms before sending to the main actor

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scaleImage(by factor: Double) {
  }

  func applyAnotherEffect() {
  }
}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()

  // Slide content start
  @concurrent
  func scaleAndDisplay(imageName: String) async {
    let image = loadImage(imageName)
    image.scaleImage(by: 0.5)
    image.applyAnotherEffect()
    await view.displayImage(image)
  }
  // Slide content end

  nonisolated
  func loadImage(_ imageName: String) -> MyImage {
    // decode image
    return MyImage()
  }
}

22:06 - Closures create shared state

import Foundation

struct Color { }

nonisolated class MyImage {
  var width: Int
  var height: Int
  var pixels: [Color]
  var url: URL

  init() {
    width = 100
    height = 100
    pixels = []
    url = URL("https://swift.org")!
  }

  func scale(by factor: Double) {
  }

  func applyAnotherEffect() {
  }
}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()

  // Slide content start
  @concurrent
  func scaleAndDisplay(imageName: String) async throws {
    let image = loadImage(imageName)
    try await perform(afterDelay: 0.1) {
      image.scale(by: 0.5)
    }
    await view.displayImage(image)
  }

  nonisolated
  func perform(afterDelay delay: Double, body: () -> Void) async throws {
    try await Task.sleep(for: .seconds(delay))
    body()
  }
  // Slide content end
  
  nonisolated
  func loadImage(_ imageName: String) -> MyImage {
    // decode image
    return MyImage()
  }
}pet.

23:47 - Network manager class

import Foundation

nonisolated class MyImage { }

struct Connection {
  func data(from url: URL) async throws -> Data { Data() }
}

final class NetworkManager {
  var openConnections: [URL: Connection] = [:]

  func openConnection(for url: URL) async -> Connection {
    if let connection = openConnections[url] {
      return connection
    }

    let connection = Connection()
    openConnections[url] = connection
    return connection
  }

  func closeConnection(_ connection: Connection, for url: URL) async {
    openConnections.removeValue(forKey: url)
  }

}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()
  let networkManager: NetworkManager = NetworkManager()

  func fetchAndDisplayImage(url: URL) async throws {
    if let image = cachedImage[url] {
      view.displayImage(image)
      return
    }

    let connection = await networkManager.openConnection(for: url)
    let data = try await connection.data(from: url)
    await networkManager.closeConnection(connection, for: url)

    let image = await decodeImage(data)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data) async -> MyImage {
    // decode image
    return MyImage()
  }
}

25:10 - Network manager as an actor

import Foundation

nonisolated class MyImage { }

struct Connection {
  func data(from url: URL) async throws -> Data { Data() }
}

actor NetworkManager {
  var openConnections: [URL: Connection] = [:]

  func openConnection(for url: URL) async -> Connection {
    if let connection = openConnections[url] {
      return connection
    }

    let connection = Connection()
    openConnections[url] = connection
    return connection
  }

  func closeConnection(_ connection: Connection, for url: URL) async {
    openConnections.removeValue(forKey: url)
  }

}

final class View {
  func displayImage(_ image: MyImage) {
  }
}

final class ImageModel {
  var cachedImage: [URL: MyImage] = [:]
  let view = View()
  let networkManager: NetworkManager = NetworkManager()

  func fetchAndDisplayImage(url: URL) async throws {
    if let image = cachedImage[url] {
      view.displayImage(image)
      return
    }

    let connection = await networkManager.openConnection(for: url)
    let data = try await connection.data(from: url)
    await networkManager.closeConnection(connection, for: url)

    let image = await decodeImage(data)
    view.displayImage(image)
  }

  @concurrent
  func decodeImage(_ data: Data) async -> MyImage {
    // decode image
    return MyImage()
  }
}

- 0:00 - 简介
- Swift 并发使 App 能够同时执行多个任务，从而提升响应速度并将计算任务转移到后台。Swift 的并发模型通过显式引入并发、识别并发任务之间共享的数据以及在编译时识别潜在的数据争用，使正确编写并发代码变得更容易。 App 会首先在主线程上运行所有代码。随着复杂性增加，可以引入异步任务来执行网络访问等高延迟操作。后台线程可用于执行计算密集型任务。Swift 提供了 Actor 和 Task 等工具来表达这些并发操作。
- 3:17 - 单线程代码
- 在 Swift 中，单线程代码在主线程上运行，主线程与主 Actor 分离。主 Actor 上没有并发，因为只有一个主线程可以运行它。你可以使用 @MainActor 注释来指定主 Actor 上的数据或代码。 Swift 将确保主 Actor 代码只在主线程上运行，并且只能从主线程访问主 Actor 数据。我们称此类代码与主 Actor 隔离。默认情况下，Swift 使用主 Actor 保护主线程代码，从而确保可以自由访问共享状态。默认情况下，使用主 Actor 保护代码的功能由构建设置驱动。这主要用于你的 App 主模块以及任何专注于 UI 交互的模块。
- 6:00 - 异步任务
- Swift 并发使用 async 和 await 将函数设为非阻塞函数，从而允许在等待数据 (如网络请求) 的同时运行其他工作。这可以通过将函数分解为在等待事件之前和之后运行的部分，来防止挂起并提高 UI 响应速度。
- 7:24 - 交错执行
- 异步函数在一个任务中运行，将独立于其他任务执行。单线程可以在独立任务就绪后将它们交替运行，也就是使用“交错”机制。这样可以通过避免空闲时间来提高性能，并高效利用系统资源。当同时执行多个独立操作时，多个异步任务处于有效状态。当按特定顺序执行工作时，请使用单个任务。通常在单线程中使用异步任务就足够了。如果主线程负担过重，Instruments 等性能分析工具可以帮助在引入并发之前识别出需要优化的瓶颈。
- 10:22 - 并发简介
- 并发允许部分代码在后台线程上与主线程并行运行，通过使用系统中的更多 CPU 内核来更快地完成工作。为了提高性能，这里的示例引入了并发以在后台线程上运行代码，从而释放主线程。
- 11:07 - 并发函数
- 应用 @concurrent 属性，就可以指示 Swift 在后台运行一个函数。Swift 编译器会突出显示主 Actor 上的数据访问，以安全地引入并发。为了确保工作同步进行，一种最佳实践是将主 Actor 代码移至始终在主线程上运行的调用程序中。
- 13:10 - 非限定代码
- @concurrent 函数总是会脱离 Actor 运行。“nonisolated”关键字允许客户端选择运行代码的位置 (main 或 background)。对于通用资源库，建议提供非隔离的 API，并让客户端自行决定是否转移工作。有关更多并发选项，请参阅 WWDC23 中的“超越结构化并发的基础”。
- 14:13 - 并发线程池
- 将工作转移到后台时，系统会管理在并发线程池中的线程上的工作调度。较小的设备可能在池中拥有较少的线程，而具有较多内核的较大系统则将具有较多线程。任务会分配给池中的可用线程，这些线程可能会随着任务的暂停和恢复而变化，从而优化资源利用率。
- 14:58 - 共享数据
- 在使用并发并在不同线程之间共享数据时，访问共享的可变状态可能会引入运行时错误。Swift 的设计将通过提供编译时检查来帮助缓解这个问题，使开发者能够更自信地编写并发代码。
- 15:49 - 值类型
- 在处理并发任务时，使用值类型具有显著优势。当将值类型拷贝到后台线程时，会创建一个独立的副本，从而确保在主线程上所做的任何更改都不会影响后台线程的值。这种独立性使得值类型可以安全地在线程之间共享。符合“Sendable”协议的值类型始终可以安全地并发共享。主 Actor 类型隐式符合 Sendable。
- 17:16 - Actor 限定类型
- Swift Actor 通过确保单任务访问来保护非 Sendable 状态。当与 Actor 之间互相发送值时，Swift 编译器会验证安全性。
- 18:30 - 类
- 在 Swift 中，类是引用类型，这意味着通过一个变量对对象进行的更改将对所有指向这个对象的变量可见。当多个线程同时访问和修改同一个非 Sendable 对象时，可能会导致数据争用、崩溃或故障。Swift 的并发系统会强制仅在 Actor 和 Task 之间共享 Sendable 类型，从而防止在编译时发生这种情况。为了避免数据争用，确保可变对象不被并发共享至关重要。在将对象发送到另一个 Task 或 Actor 进行显示或处理之前，请先完成对对象的修改。如果需要在后台线程上修改对象，请将它设置为“nonisolated”状态，但不要设置为 Sendable。具有共享状态的闭包只要不被并发调用，也可以是安全的。
- 23:18 - Actor
- 随着 App 的发展，主 Actor 可能会管理大量状态，从而导致频繁的上下文切换。引入 Actor 可以缓解这种情况。Actor 会隔离这些数据，一次只允许一个线程进行访问，从而避免争用。将状态从主 Actor 转移到专用 Actor，就可以在后台线程上并发执行更多代码。这样可以释放主线程，以确保响应能力。面向 UI 的类和模型类通常需要保留在主 Actor 上，或者保持非 Sendable 状态不变。
- 26:12 - 总结
- App 通常最初是单线程的，然后逐渐演变为使用异步任务、并发代码和 Actor 以提升性能。Swift 并发有助于实现这一转变，使代码更容易从主线程移出并提升响应速度。Instruments 等性能分析工具有助于识别何时以及哪些代码需要从主线程移出。请使用推荐的构建设置来帮助简化并发的引入，并使用“渐进式并发”设置实现一系列即将推出的功能，从而更轻松地使用并发。

章节

资源

相关视频

WWDC25

WWDC23