Swift 的新功能

Swift 的新功能

与我们一起了解 Swift 的最新更新。我们将讨论有助于提高效率的工作流程改进，以及用于处理基本编程任务的全新现代 API 资源库。我们还将举例说明 Swift 在软件堆栈各层的广泛采用情况。最后，我们将探索新的语言特性，这些特性有助于提高并发易用性，同时确保在需要时实现最佳性能。

章节
- 0:00 - Introduction & Agenda
- 0:48 - swiftlang updates
- 3:06 - Development workflow: Writing code
- 4:40 - Development workflow: Building
- 7:36 - Development workflow: Debugging
- 9:14 - Libraries: Subprocess
- 10:45 - Libraries: Foundation
- 12:31 - Libraries: Observation
- 14:13 - Libraries: Testing
- 16:08 - Swift throughout the stack: Embedded Swift
- 18:00 - Swift throughout the stack: Security
- 19:37 - Swift throughout the stack: Server
- 23:23 - Swift throughout the stack: Platforms
- 26:11 - Language evolution: Performance
- 30:28 - Language evolution: Concurrency
- 37:15 - Wrap up
资源
相关视频

WWDC25
WWDC24
大家好欢迎观看 “Swift 的新功能”讲座我是 Holly 我是 Allan 今天我们将介绍 Swift 6.2 中的新功能和改进这些改进旨在帮助你成为一名更高效的 Swift 程序员无论你选择在哪里编写代码也无论你编写哪种代码都能助你提高效率首先我们将介绍编写、构建和调试代码时所遵循的工作流程有哪些改进然后我们将介绍用于处理基本编程任务的全新 Library API 此外我还将介绍如何在软件堆栈的每一层采用 Swift 最后我们将探索新的语言功能这些功能使并发机制更易于实现并有助于你在需要时实现峰值性能我们今天介绍的所有更改都是在开源中共同开发的 GitHub 上的 swiftlang 组织已经发展壮大到拥有 50 多个项目包括编译器、swift.org 网站、基础库和测试库以及其他支撑更广泛生态系统的关键组成部分除了将项目迁移至 swiftlang 我们还开源了 Xcode 的构建系统即 Swift Build Swift Build 还支持 Apple 操作系统的构建流程开发者正在通过开源方式采用 Swift Build 作为 Swift Package Manager 的底层构建系统这将统一 Xcode 与 swift.org 工具链之间的构建引擎要进一步了解 Swift Build 请查看 “The Next Chapter in Swift Build Technologies”博客文章 Swiftlang 项目的一个最新成员是名为 Swiftly 的版本管理器 Swiftly 最初是由开源社区开发的用于简化 Linux 上的 Swift 工具链管理 Swiftly 现在支持 macOS 并且 swift.org 上已提供 1.0 版只需输入一个命令便可以安装最新的 Swift 工具链或者你也可以从 GitHub 分支安装一个夜间快照以试用开发中的语言功能在 Xcode 中可通过 Toolchain 的菜单访问 Swiftly 安装的工具链请记住如果你正在构建 App 你仍需要使用 Xcode 工具链将你的 App 提交到 App Store 在 VS Code 中你可以使用 Toolchain 命令来选择 Swiftly 安装的工具链要进一步了解 Swiftly 1.0 你可以查看 Swift 博客 Swift 入门体验的更新不仅仅限于安装工具 Swift.org 主页焕然一新更专注于帮助你深入探索不同的领域从 App 开发到云服务再到嵌入式系统这项工作是与 Swift Website 工作组合力完成的上手使用 Swift 从未如此简单 Allan 将介绍 Swift 6.2 如何让你更灵活地打造一个合适你的开发环境谢谢 Holly 今年的 Swift 版本针对开发工作流程进行了诸多改进无论你选择如何编写 Swift 代码都能充分获益这些改进涵盖各种工作流程包括编写代码、构建以及调试我们先来看看今年有哪些适用于 VS Code 开发者的新功能
VS Code 市场中的 Swift 扩展现已由 swift.org 验证和分发它在过去的一年里新增了许多新功能第一项功能是后台索引在 Swift 6.1 中我们默认针对 VS Code 和其他 IDE 中的 Swift PM 项目启用了后台索引这样一来在你更改项目时诸如跳转到定义等编辑器功能便会保持最新状态得益于 SourceKit-LSP 所作的改进 VS Code 中的代码补全结果现在变得更相关此外调试也得到了简化现在当你安装 Swift 扩展时 LLDB 支持会自动添加这个扩展的最新版本还包含一个新的项目面板让你可以轻松找到软件包的依赖项、目标和任务最后 VS Code Swift 扩展还提供了一种新的方式供你查看项目的文档你可以调出与代码并排显示的 DocC 预览功能这个功能会在你键入代码时实时更新 VS Code Swift 扩展是在开源中开发的你可以在 swiftlang 组织中的 GitHub 上找到它接下来我们将谈谈 Swift 代码构建方面的一些改进无论在哪里这些改进都适用于你对工作效率影响最大的一个方面是工具的性能
对于那些使用基于宏的 API 的项目 Swift 6.2 显著缩短了清洁构建的时间为了一探究竟假设你有一个项目它使用名为 Stringify 的虚拟软件包中的宏以前为了构建你的项目 Swift PM 必须先获取 swift-syntax 的源代码 Swift-syntax 是一个用于为宏提供支持的库然后，它将构建 swift-syntax、构建 Stringify 宏插件并最终构建你的代码尽管 swift-syntax 的构建结果可能被缓存起来但它仍会导致执行干净构建所需的时间延长这一点在持续集成环境中可能尤为明显为了加快构建速度最新版本的 Swift PM 和 Xcode 支持预构建的 swift-syntax 依赖项这完全消除了开销较大的构建步骤对于某些项目这还会将干净构建的时间缩短数分钟
如果你拥有一个提供宏的软件包你的客户端将能够充分利用这项优化功能只要这个软件包依赖于 swift-syntax 的标记版本即可你的工作效率并不总是只与构建性能有关有时尝试解决编译器发现的问题会放慢你的速度例如当你在 Swift 6 语言模式下编写并发代码时编译器可能会检测到你需要防范的潜在数据争用这条错误信息指出了一个比较重要的问题但并没有明确指明如何解决这个问题因此我们在 Swift 6.2 中开始对文档内容进行扩充针对很多类型的诊断提供了相关的文档说明这些针对常见警告和错误的解释说明可帮助你了解问题并为你提供了具体的解决方案你可以从 IDE 中或在 swift.org 网站上访问相关文档控制诊断程序的工作方式也很重要例如要确保代码不显示警告你可以使用 “warnings as errors”设置这项设置适用于那些比较容易处理的警告但对于某些警告比如那些涉及已弃用的 API 的警告你可能不希望被强制要求立即处理 SWIFT 6.2 让你能够灵活地决定将哪些警告视为错误例如你可以决定默认将所有警告均视为错误但已弃用的声明则除外另一方面如果你只想阻止显示某些类别的警告你可以直接将相应警告升级为错误针对编译器警告添加控制功能充分彰显了整个社区为提升所有开发者的 Swift 开发体验而共同付出的努力感谢提案撰写者以及在论坛上参与讨论的每一个人最后我们来看看 Swift 6.2 中在调试方面做出的一些重大改进
在这个版本中我们大幅提升了异步代码的调试体验在你逐步调试某个 Swift 任务中运行的代码时 LLDB 现在会跟随执行流程进入异步函数即使需要在线程之间切换也不例外调试器对 Swift 以任务为中心的模型的理解使它能够显示哪个任务正在执行你甚至可以命名一个任务让它更便于识别任务名称还会显示在 Instruments 描述文件中这些文件记录在 Instruments 并发模板中你还可以使用 swift task info 等新命令获取当前所执行任务的更多信息例如任务的优先级及其子任务最后你的调试会话从今年起将变得更灵敏这要归功于显式构建的模块这一构建系统功能这项功能可在构建模块依赖项时实现并行性和重用性在显式构建的模块推出之前 Xcode 构建和调试器会使用完全独立的模块图现在调试器能够重用构建时生成的模块这意味着首次在调试器中运行 P 或 PO 时这个命令的评估速度将明显变快因为类型信息会立即可用 Xcode 26 中默认会启用显式构建的模块今年我们在工具方面对 Swift 进行了众多改进刚刚只介绍了其中的一小部分接下来我将带你了解一些我们针对日常使用的 Swift 核心库所做的重要更新库可帮助你完成各种各样的任务 Swift 的核心库提供了一些重要的构建块用于编写 Swift 代码 Swift 6.2 针对 Foundation 的更多 API 表面进行了现代化改进并提供了一些新 API 来简化日常编程任务为了提升使用 Swift 完成脚本编写任务的体验 Foundation Workgroup 推出了一个新的软件包其中包含用于启动子进程的 API 首先应添加并导入新的 Subprocess 软件包然后通过调用 run 函数并等待结果来启动一个子进程如果你提供一个带有进程名称的字符串 run 方法将基于 $PATH 环境变量来查找可执行文件
大多数情况下你需要使用 FilePath 指定某个可执行文件的路径以启动一个子进程当子进程终止时你可以检查退出状态、标准输出以及其他有关进程执行情况的信息子进程库提供了更多功能让你能够对进程执行、特定于平台的配置选项等内容进行精细控制你可以在 swift-subprocess 存储库中探索完整的 API 接口集合这个软件包的当前版本为 0.1 版你在采用期间提供的反馈将为我们在 1.0 版中发布的 API 提供参考 Foundation Workgroup 还对 App 项目中最常用的日常 API 进行了改进在 iOS App 中针对来自 UIKit 的通知做出响应是一项很常见的操作但用于观察通知的代码很容易出错首先你必须小心地注册一个对象支持发布的通知名称如果出现错误你的通知回调将永远不会运行与通知有关的信息储存在非类型化的字典中这要求你使用正确的键手动进行下标访问并将所得结果动态转换为正确的类型即使能保证通知在主线程上发布你在访问主 Actor API 时仍会收到并发错误通知名称和有效负载现在支持具体类型具体类型让编译器能够检查对象是不是支持你所注册的通知类型它们还会在处理通知有效负载时消除样板代码通知类型指定了通知的发布位置如果通知发布在主 Actor 上你可以自由访问主 Actor API 遵从 MainActorMessage 可确保通知始终在主线程上同步发布遵从 AsyncMessage 意味着通知在任意线程上异步发布对于由 UIKit 和 Foundation 等框架发布的通知 SDK 中提供了具体的通知类型你也可以为自己的通知添加具体的通知类型向注册的观察器广播系统通知基于更通用的观察器模式 Observation Library 提供了通用 API 用于自动追踪对象图中的状态变化
你可以使用 @Observable 宏将一个类纳入观察追踪的范围 Swift 6.2 推出了一种通过 AsyncSequence 从可观察类型中流式传输状态变化的方法首先使用闭包来创建新 observations 类型的实例在闭包中你需要计算要观察其变化的值在这里我想观察一个描述玩家当前状态的字符串并希望每次更新分数或玩家获得新项目时都能获得一个新的值你将获得一个基于闭包中使用的可观察属性而更新的值更新以交易方式进行。当闭包中任一可观察属性的 willSet 被调用时将开始追踪更新追踪进程将在代码暂停的下一个 await 处结束更新后的值将包含针对这两个代码点之间的其他属性所做的所有同步更改这可以确保针对多个属性进行的同步更新不会在对象处于不一致状态时引发观察更新
如果我同步更新分数和项目我只会获得一个更新后的值其中包含这两项更改观察结果类型遵从 AsyncSequence 因此你可以使用 for-await 循环来迭代更新后的值作为开发者我们每天都会编写测试 Swift Testing 是一个跨平台库提供了多个用于描述和组织测试的宏比如用于声明测试函数的 @Test 属性你使用 expect 和 require 宏来验证自己的假设当预期或要求失败时 Swift Testing 会为你提供可操作的信息但有时测试失败很难进行分类尤其是当测试仅在 CI 等远程环境中失败时了解测试失败可能需要获取更多有关测试所用数据的上下文
Swift 6.2 推出了自定附加功能来帮助你诊断测试失败你可以调用 Attachment.record 方法将附加功能添加到测试你可以附加 Data 和 String 等库类型并可以通过遵从 attachable 协议来针对你自己的类型实现附加支持 Swift 6.2 还支持退出测试用于测试你期望在某些条件下终止的测试代码例如如果你编写一个函数以通过 precondition 来验证有关输入参数的假设你可以编写一个用于测试 precondition 是否失败的测试用例
你通过将 processExitsWith 参数传递给 #expect 或 #require 来编写退出测试当你编写退出测试时 Swift Testing 将启动一个新的进程来运行这个测试你可以通过某一特定的退出代码或信号或通过任何失败状态来验证进程是否成功退出这些通用库让你可以在整个项目中甚至在应用程序代码的外部编写和测试可移植 Swift 代码在 Apple 我们在整个软件堆栈中使用 Swift 我们将它用于固件、App 和框架以及大规模的网络服务在针对嵌入式设备、关乎安全的组件以及服务器编写代码时你可以充分利用 wift 6.2 中的改进你还可以针对一些新平台编写代码我们将从堆栈底部的 Embedded Swift 开始介绍 Embedded Swift 是 Swift 的子集用于针对最受限的环境编写代码这类环境包括嵌入式设备的固件以及操作系统内核等它是一个支持 Swift 核心特性的编译模式这类特性包括值和引用类型、闭包、可选类型错误处理、泛型等在 Apple 我们将 Embedded Swift 应用于在 iPhone 上运行的一些最底层软件中例如在 iOS 26 中 Embedded Swift 运行在用于管理 CPU 与 GPU 之间的共享内存页面访问权限的协处理器上如果你想试用 Embedded Swift 你可以观看 “利用 Embedded Swift 实现轻量级开发”讲座来了解更多信息 Swift 6.2 推出了一些新功能实现了对 Embedded Swift 的扩展它现在涵盖 Swift 的全部字符串 API 其中包括字符串插值现在当某一协议受限于 class 类型时可以使用 Swift 的 any 类型这个类型可以表示那些遵从这个协议的类型的值 Swift 标准库还引入了 InlineArray 和 Span 这是两个用于高效处理内存区域的新 API 这些类型适用于那些常见于嵌入式程序并且对性能要求很高的代码稍后 Holly 将更详细地介绍这些类型随着嵌入式 Swift 变得越来越强大社区一直在忙于创建示例你可以参考这些示例来开始创建自己的嵌入式项目要查看这些示例请访问 GitHub 的 swift-embedded-examples 存储库 Embedded Swift 的好处之一是让你可以用一种默认情况下内存安全的语言来编写底层软件内存安全代码的安全性更高我们一直在努力改进 Swift 使其更适合编写在安全性方面要求极为苛刻的代码有时你需要编写代码来完成从根本上而言并不安全的事情例如在与用 C 语言编写的依赖项整合时通常使用一个采用指针的 API 在安全性至关重要的上下文中应尽可能避免不安全的代码但如果无法避免则应该让不安全代码易于识别这就是我们为什么在 Swift 6.2 中推出了一项名为严格内存安全的全新可选功能这个模式要求使用的所有不安全 API 都能在源代码中得到明确的识别这个模式所需的注释可帮助你识别代码的哪些部分需要从安全性角度受到额外的关注除了这个新模式外 Swift 6.2 还支持为 C 和 C++ 标题添加新的注释这些注释会导致 API 能够以诸如 Span 这样安全且符合人体工程学的类型导入 Swift 要进一步了解新的互操作性功能请观看“安全地混合使用 C、 C ++ 和 Swift”讲座在 Apple 的操作系统中我们将在两个安全性至关重要的组件中采用严格内存安全功能：分别是 WebKit 和“信息”App 的子系统这个系统会分析收到的信息和附件由于这两个组件都会处理不受信任的输入因此应限制不安全 API 的使用这一点至关重要接下来我们了解一下 Swift 在服务器生态系统中的应用
Swift 在我们的 Apple 服务中发挥着至关重要的作用后台服务每秒钟会处理数百万个请求这些服务均由 Swift 提供强大支持其中一项服务负责提醒用户留意被盗的密码因为它们在数据泄露事件中被发现这项服务以前是用 Java 构建的最近用 Swift 进行了重写这样做的好处是显而易见的得益于 Swift 高效的原生代码和确定性内存管理机制服务的吞吐量提升了 40% 而硬件要求则降低了一半
在服务器上采用 Swift 会给你们中的很多人带来好处例如 Cultured Code 的工程师用 Swift 针对广受欢迎的 “Things”App 重新实现了后台服务 Things Cloud 并且在 swift.org 上分享了相关体验
对于 Things Cloud 使用 Swift 会使计算成本降低三倍同时会使平均响应时间缩短 400% 除了提升性能外采用 Swift 的另一个好处是能够使用相同的语言和工具进行客户端和服务器开发团队之所以能够使用 Swift 构建服务器后端一个关键因素在于 Swift 丰富的库 Swift 拥有一个不断扩大的软件包生态系统涵盖各种各样的重要使用场景 Swift 提供了适用于联网、数据库驱动程序、可观测性、消息流等内容的资料库今年一个值得关注的更新是 gRPC Swift 版本 2 的发布 gRPC 是一个用于构建服务 API 的现代化、高性能软件包版本 2 的亮点之一是现代化的 API 它们利用 Swift 并发机制、以惯用方式生成的 Swift 代码以及可插拔的高性能传输层 gRPC Swift 的维护者在 swift.org 上写了一篇关于更新的博客文章请查看这篇文章来了解更多信息与 C、Objective-C 和 C++ 的互操作性是 Swift 核心优势之一通过一次更新一个文件的方式采用 Swift 你可以逐步改进用这些语言编写的现有代码库在服务器生态系统中许多现有应用程序都是用 Java 编写的我们认为在这些代码库中也非常适合以增量方式采用 Swift 这就是为什么我们在去年宣布推出了一个激动人心的新开源项目： swift-java 它的目的是使各种语言能够实现无缝整合
通过 swift-java 你可以创建绑定来允许 Swift 代码调用 Java 代码反之亦然这些绑定旨在包装每种语言的值的原生表示而不会产生大量开销 Swift 代码的 Java 绑定可以利用 Java 的新一代外部接口技术或者在必要时回退到 JNI swift-java 项目目前正处于实验阶段并且发展迅速要进一步了解这个项目的工作方式请观看“探索 Swift 和 Java 互操作性”讲座
在创建同时包含客户端和服务器组件的 App 时你需要设计一个能够在本地测试你的代码在这两个环境中运行情况的工作流程 Apple 发布了一个新的开源 containerization 库你可以使用这个库基于 Mac 上运行的 Linux 容器来构建工具这个库完全用 Swift 实现并且在设计时着重考虑了安全性、隐私和性能这个库充分体现了使用 Swift 进行系统级开发的好处要进一步了解这个库请观看 “了解 Containerization”讲座你也可以访问 GitHub 上的 containerization 存储库在那里你可以找到用于运行容器的命令行二进制文件最后我们介绍一些有关 Swift 支持的平台的更新 Swift 6.2 新增了对 FreeBSD 这一操作系统的官方支持这个系统在服务器和嵌入式平台上备受欢迎此外，Swift 现在还支持 WebAssembly (也称为 Wasm) WebAssembly 是一个虚拟机平台专注于可移植性、安全性和高性能开发者可以为 Wasm 构建客户端和服务器应用程序然后将它们部署到浏览器或其他运行时 WebAssembly 支持最初是一个社区项目今年早些时候这个项目达到了一个重要里程碑并发布了一份愿景文档来阐述 Swift 中为 WebAssembly 提供的官方支持下面我们看一看 Wasm 支持是如何发挥作用的我有一个用 Swift 编写的 App 它从文件中载入 3D 模型然后在浏览器中进行渲染接下来显示的是这个 App 目前的外观
这个 App 运行在 Wasm 虚拟机上 Swift 标志是使用 WebGPU 渲染的这个 Web 标准目前处于实验状态
这个 App 使用 JavascriptKit 它是一个由 SwiftWasm 组织开发的开源软件包我可以使用这个库通过原生 Swift API 与 Javascript 运行时进行交互为了让最终的二进制文件尽可能紧凑我将使用 Embedded Swift 来编译这个 App 但总的来说这个代码只是普通的 Swift 代码
例如我添加了一些利用泛型的几何图形实用工具我的 Wavefront 对象文件解析器使用 Swift 的原生 String API
我们将添加一些动画我将跳转到我们渲染器的 update 方法
为了给模型添加旋转效果标志的旋转状态需要在每一帧都更新
我们来测试一下吧为了重新运行这个应用程序我从项目面板中触发了一个任务这个任务被配置为调用 Swift Build 来编译 Wasm App 然后它将在构建输出上运行几个最小化工具以确保二进制文件尽可能小最后它将启动一个网页服务器来托管内容效果看起来很棒 Swift 之所以在整个软件堆栈中是一个绝佳选择核心在于它是一种很棒的语言 Swift 默认会优先保证安全性和易用性但与此同时也针对高级编程提供了相应工具可帮助你编写复杂代码并进行调整以实现最佳性能你可以根据需要了解语言功能你可以从基础功能开始了解做好准备后再深入了解高级功能
Swift 6.2 改进了语言无论是初学者还是专家都更容易上手使用我们为在项目中引入并发性提供了一条更便捷的途径我们还让这个语言在专家编写性能关键代码时能提供强大的支持我们先了解一下性能方面的更新 Array 类型是一个按序排列的元素列表也是 Swift 项目中最常用的一种数据类型 Array 具备的强大功能 (如动态调整大小) 使其易于使用并且适用于很多任务但这种灵活性是有代价的为了支持动态调整大小数组会储存对堆分配的缓冲区的引用在添加更多元素并且数组已达到最大容量时必须动态分配新内存并将现有元素拷贝到新内存如果你对性能关键代码进行分析并且这个代码在热路径中使用 Array 则你可能会注意到数组缓冲区存在需要消除的内存分配或引用计数开销如果数组的大小永远不会改变则无需承担因堆分配而产生的开销 InlineArray 是一个固定大小的新数组类型它通过内联存储来存储元素大小是类型的一部分并且在尖括号中位于元素类型之前
InlineArray 的元素是直接储存的而不是储存对包含元素的缓冲区的引用这意味着元素可以储存在堆栈上或直接储存在其他类型中而无需进行额外的堆分配 InlineArray 可以储存可拷贝和不可拷贝的类型储存可拷贝的类型时可以拷贝 InlineArray 本身并且元素类型会立即拷贝要将大小编写为类型的一部分可以使用新的泛型功能来允许将整数作为类型参数和元素类型一样 InlineArray 的大小可以从数组字面值推断出如果你编写一个包含 1、2 和 3 的内联数组则类型会被推断为包含 3 个整数的 InlineArray 在编译时知晓 InlineArray 的大小还可以实现更多的优化例如当索引小于大小时消除边界检查 container 类型通常需要提供对其底层存储的直接访问这对于在连续内存上执行本地处理很有用因为无需知道原始容器的布局例如一个函数可能需要允许直接对 Array 或 InlineArray 的连续存储执行操作在 Swift 6.2 推出之前常见解决方案是使用不安全的指针这些指针虽然有效但从根本上来说是不安全的并且容易出错
新的 Span 类型是一种抽象可针对连续内存提供快速直接的访问而不会影响内存安全性标准库为所有将连续存储用于自身元素的容器类型 (包括 Array、ArraySlice、 InlineArray 等) 提供了 span 属性
Span 维护内存安全的方法是确保在你使用 Span 时使连续内存保持有效状态这样的保障机制消除了指针固有的内存安全问题包括释放后使用和重叠的修改这些问题会在编译时进行检查而不会产生运行时开销例如修改原始容器会阻止随后访问 span 修改后你将无法再次访问 span 变量
另外 span 的生命周期无法超过原始容器这被称为生命周期依赖它可以防止底层存储在仍可以通过 span 进行访问的情况下被销毁要了解使用 InlineArray 和 Span 控制性能的新方式请观看“优化 Swift 代码的内存使用和性能”讲座要进一步了解如何理解 Swift 代码的性能特性请观看“探索 Swift 性能”讲座
当程序需要同时执行多项任务时性能的另一个方面是响应速度并发编程并非易事因为在多项任务之间共享内容容易出错从而导致不可预测的行为 Swift 6 中的数据争用安全保障机制可以在编译时防止出现这些错误因此你可以放心编写并发代码而不用担心会产生难以调试的运行时错误但在很多情况下你编写的最自然代码容易出现数据争用从而导致产生必须解决的编译器错误对于具有可变状态的类比如这个 PhotoProcessor 类只要你不对它进行并发访问它就是安全的它有一个 async 方法这个方法通过计算给定图像数据的主题来提取贴纸但如果你尝试在主 Actor 上调用 UI 代码中的 extractSticker 你就会收到一个错误提示这个调用可能会导致数据争用这是因为语言中存在一些机制会将工作隐式转移到后台即使你从不需要代码并行运行也是如此
Swift 6.2 更改了这个设计理念在你选择引入并发机制之前它默认会一直保持单线程状态
Swift 6.2 中的语言更改使编写的最自然代码默认不会出现数据争用这为在项目中引入并发机制提供了一条更便捷的途径当你因为想要并行运行代码而选择引入并发机制时数据争用安全保障机制会为你提供保护首先我们使得在具有可变状态的类型上调用 async 函数变得更简单对于那些未与特定 Actor 绑定的 async 函数语言不会立即转移它们而是让函数在其被调用的 Actor 上继续运行这消除了数据争用因为传递到 async 函数的值永远不会在 Actor 之外发送 Async 函数仍可以在自身的实现中转移工作但客户端不必担心它们的可变状态
接下来我们使得在主 Actor 类型上实现遵从性变得更简单这里有一个名为 Exportable 的协议我想为我的主 Actor StickerModel 类实现遵从性由于 export 要求不具备 Actor 隔离机制因此语言假设它可以从非主 Actor 那里被调用并禁止 StickerModel 在其实现中使用主 Actor 状态
Swift 6.2 支持这些遵从性需要知晓主 Actor 状态的遵从性称为*隔离的*遵从性这是安全的因为编译器会确保主 Actor 遵从性只在主 Actor 上使用我可以创建一个 ImageExporter 类型用于将 StickerModel 添加到 any Exportable 项目的数组中只要它留在主 Actor 上即可但如果我允许从任何地方使用 ImageExporter 编译器将会禁止将 StickerModel 添加到数组因为从主 Actor 外部对 StickerModel 调用 export 是不安全的借助隔离的遵从性当代码指明要以并发方式使用遵从性时你只需解决数据争用安全问题
全局变量和静态变量容易出现数据争用因为它们允许从任何位置访问可变状态
保护全局状态的最常见方式是使用主 Actor 一种常见做法是用主 Actor 标注整个类以保护它的所有可变状态尤其是在并发任务数量并不多的项目中通过在项目中的所有内容上标注 @MainActor 你可以对一个完全单线程的程序进行建模为了让你更轻松地对单线程代码进行建模我们推出了一个能够默认推断主 Actor 的模式它可以消除因不安全的全局变量和静态变量、针对其他主 Actor 函数 (例如 SDK 中的主 Actor 函数) 的调用等而引发的数据争用安全错误因为主 Actor 默认会保护所有可变状态另外它还减少了基本上属于单线程的代码中的并发注释对于那些在主 Actor 上完成大多数工作并将并发代码封装在特定类型或文件中的项目而言这个模式非常适用它是可选的建议将它用于 App、脚本以及其他可执行目标将工作转移到后台对于确保性能仍很重要例如在执行那些占用大量 CPU 资源的任务时确保 App 响应灵敏我们来看看 PhotoProcessor 上 extractSticker 方法的实现它首先检查是否已经为图像提取了贴纸以便立即返回缓存的贴纸如果贴纸还没有被缓存它会从图像数据中提取主题并创建一个新贴纸 extractSubject 方法会执行开销很高的图像处理因此我不希望阻止主 Actor 或任何其他 Actor 我可以使用 @concurrent 属性转移这项工作 @Concurrent 可确保函数始终在并发线程池上运行从而释放出 Actor 来同时执行其他任务这些语言方面的变化通过相互配合让并发机制更容易实现首先编写默认在主 Actor 上运行的代码这时不存在数据争用风险当你开始使用 async 函数时这些函数会在它们被调用的任何位置运行这时仍不存在数据争用风险因为你的所有代码仍在主 Actor 上运行当你准备好采用并发机制来提高性能时可以轻松将特定代码转移到后台来并行运行如果你想要进一步了解如何在实践中使用并发机制请观看“使用 Swift 并发机制提升 App 性能”讲座要进一步了解基本的并发概念请观看“采用 Swift 并发”讲座在这些语言变化中有些是可选的因为它们要求你更改项目才能适配要查找和启用所有与并发机制有关的适用语言变化请访问 Xcode 构建设置的 “Swift Compiler - Concurrency”部分你还可以使用 SwiftSettings API 在 Swift 软件包中启用这些功能 Swift 6.2 提供了迁移工具来帮助你自动完成必要的代码更改你可以访问 swift.org/migration 来进一步了解迁移工具这些并发方面的改进是根据你就如何在项目中采用数据安全机制提出的反馈而打造的无论你是报告了错误、就某个不理解的并发错误提出了问题、在论坛上查看了改进建议还是亲自编写了语言方面的更改你的意见都至关重要感谢你为了让每个人更容易上手使用并发机制而给予的帮助如果你想参与改进 Swift 请前往 swift.org 加入我们的论坛欢迎所有人参与推动这个语言和生态系统的不断向前发展我们非常期待能够在社区展示部分中听到你自己的项目开发体验你还可以通过论坛来及时了解与 Swift 有关的一切包括会议、聚会、社交媒体等等感谢你今天的参与期待在论坛上与你沟通交流

9:44 - Subprocess: Call `run` with string

import Subprocess

let result = try await run(
  .name("pwd")
)

10:04 - Subprocess: Call `run` with file path

import Subprocess

let swiftPath = FilePath("/usr/bin/swift")
let result = try await run(
  .path(swiftPath),
  arguments: ["--version"]
)

10:05 - Subprocess: Accessing standard output

import Subprocess

let swiftPath = FilePath("/usr/bin/swift")
let result = try await run(
  .path(swiftPath),
  arguments: ["--version"]
)

let swiftVersion = result.standardOutput

10:51 - NotificationCenter: Dynamic types

import UIKit

@MainActor 
class KeyboardObserver {
 func registerObserver(screen: UIScreen) {
    let center = NotificationCenter.default
    let token = center.addObserver(
      forName: UIResponder.keyboardWillShowNotification,
      object: screen,
      queue: .main
    ) { notification in
      guard let userInfo = notification.userInfo else { return }
      let startFrame = userInfo[UIResponder.keyboardFrameBeginUserInfoKey] as? CGRect
      let endFrame = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect

      guard let startFrame, let endFrame else { return }

      self.keyboardWillShow(startFrame: startFrame, endFrame: endFrame)
    }
  }
  
  func keyboardWillShow(startFrame: CGRect, endFrame: CGRect) {}
}

11:34 - NotificationCenter: Concrete types

import UIKit

@MainActor
class KeyboardObserver {
  func registerObserver(screen: UIScreen) {
    let center = NotificationCenter.default
    let token = center.addObserver(
      of: screen,
      for: .keyboardWillShow
    ) { keyboardState in
      let startFrame = keyboardState.startFrame
      let endFrame = keyboardState.endFrame

      self.keyboardWillShow(startFrame: startFrame, endFrame: endFrame) 
    }
  }
  
  func keyboardWillShow(startFrame: CGRect, endFrame: CGRect) {}
}

12:01 - NotificationCenter: Conformances

extension UIResponder { 
  public struct KeyboardWillShowMessage: NotificationCenter.MainActorMessage
}

extension HTTPCookieStorage {
  public struct CookiesChangedMessage: NotificationCenter.AsyncMessage
}

12:48 - Observation: The @Observable macro

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

12:58 - Observation: The Observations type

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

let player = Player(name: "Holly")
let values = Observations {
  let score = "\(player.score) points"
  let item =
    switch player.item {
    case .none: "no item"
    case .banana: "a banana"
    case .star: "a star"
    }
  return "\(score) and \(item)"
}

13:56 - Observation: Transactional updates

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

let player = Player(name: "Holly")
let values = Observations {
  let score = "\(player.score) points"
  let item =
    switch player.item {
    case .none: "no item"
    case .banana: "a banana"
    case .star: "a star"
    }
  return "\(score) and \(item)"
}

player.score += 2
player.item = .banana

14:05 - Observation: AsyncSequence

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

let player = Player(name: "Holly")
let values = Observations {
  let score = "\(player.score) points"
  let item =
    switch player.item {
    case .none: "no item"
    case .banana: "a banana"
    case .star: "a star"
    }
  return "\(score) and \(item)"
}

player.score += 2
player.item = .banana

for await value in values { print(value) }

14:17 - Swift Testing

import Testing
import Foundation
import EvolutionMetadataModel

@Test
func validateProposalID() async throws {
  let (data, _) = try await URLSession.shared.data(from: evolutionJSONMetadataURL)

  let jsonDecoder = JSONDecoder()
  let metadata = try jsonDecoder.decode(EvolutionMetadata.self, from: data)
  for proposal in metadata.proposals {
    #expect(proposal.id.starts(with: "SE"))
  }
}

14:54 - Swift Testing: Attachments

import Testing
import Foundation
import EvolutionMetadataModel

@Test
func validateProposalID() async throws {
  let (data, _) = try await URLSession.shared.data(from: evolutionJSONMetadataURL) 
  Attachment.record(data, named: "evolution-metadata.json")

  let jsonDecoder = JSONDecoder()
  let metadata = try jsonDecoder.decode(EvolutionMetadata.self, from: data)
  for proposal in metadata.proposals {
    #expect(proposal.id.starts(with: "SE"))
  }
}

15:23 - Exit Tests: Preconditions

extension Proposal {
  public var number: Int {
    let components = id.split(separator: "-")
    precondition(
      components.count == 2 && components[1].allSatisfy(\.isNumber),
      "Invalid proposal ID format \(id); expected SE-<Number>"
    )

    return Int(components[1])!
  }
}

15:34 - Exit Tests: processExitsWith argument

import Testing
import EvolutionMetadataModel

@Test
func invalidProposalPrefix() async throws {
  await #expect(processExitsWith: .failure) {
    let proposal = Proposal(id: "SE-NNNN")
    _ = proposal.number 
  }
}

31:06 - Concurrency: Async function error message

class PhotoProcessor {
  func extractSticker(data: Data, with id: String?) async -> Sticker? {     }
}

@MainActor
final class StickerModel {
  let photoProcessor = PhotoProcessor()

  func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
    guard let data = try await item.loadTransferable(type: Data.self) else {
      return nil
    }

    return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
  }
}

32:06 - Concurrency: Run async functions on the caller's actor

// Run async functions on the caller's actor

class PhotoProcessor {
  func extractSticker(data: Data, with id: String?) async -> Sticker? {}
}

@MainActor
final class StickerModel {
  let photoProcessor = PhotoProcessor()

  func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
    guard let data = try await item.loadTransferable(type: Data.self) else {
      return nil
    }

    return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
  }
}

32:36 - Concurrency: Conformance error

protocol Exportable {
  func export()
}


extension StickerModel: Exportable { // error: Conformance of 'StickerModel' to protocol 'Exportable' crosses into main actor-isolated code and can cause data races
  func export() {
    photoProcessor.exportAsPNG()
  }
}

33:04 - Concurrency: Isolated conformances

// Isolated conformances

protocol Exportable {
  func export()
}


extension StickerModel: @MainActor Exportable {
  func export() {
    photoProcessor.exportAsPNG()
  }
}

33:20 - Concurrency: Isolated conformance use

// Isolated conformances

@MainActor
struct ImageExporter {
  var items: [any Exportable]

  mutating func add(_ item: StickerModel) {
    items.append(item)
  }

  func exportAll() {
    for item in items {
      item.export()
    }
  }
}

33:31 - Concurrency: Isolated conformance error

// Isolated conformances

nonisolated
struct ImageExporter {
  var items: [any Exportable]

  mutating func add(_ item: StickerModel) {
    items.append(item) // error: Main actor-isolated conformance of 'StickerModel' to 'Exportable' cannot be used in nonisolated context
  }

  func exportAll() {
    for item in items {
      item.export()
    }
  }
}

33:51 - Concurrency: Unsafe static variable

final class StickerLibrary {
  static let shared: StickerLibrary = .init() // error: Static property 'shared' is not concurrency-safe because non-'Sendable' type 'StickerLibrary' may have shared mutable state
}

34:01 - Concurrency: Protecting static variables

final class StickerLibrary {
  @MainActor
  static let shared: StickerLibrary = .init()
}

34:05 - Concurrency: Protecting classes

@MainActor
final class StickerLibrary {
  static let shared: StickerLibrary = .init()
}

34:15 - Concurrency: A single-threaded program

@MainActor
final class StickerLibrary {
  static let shared: StickerLibrary = .init()
}

@MainActor
final class StickerModel {
  let photoProcessor: PhotoProcessor

  var selection: [PhotosPickerItem]
}

extension StickerModel: @MainActor Exportable {
  func export() {
    photoProcessor.exportAsPNG()
  }
}

34:22 - Concurrency: Mode to infer main actor by default

// Mode to infer main actor by default

final class StickerLibrary {
  static let shared: StickerLibrary = .init()
}

final class StickerModel {
  let photoProcessor: PhotoProcessor

  var selection: [PhotosPickerItem]
}

extension StickerModel: Exportable {
  func export() {
    photoProcessor.exportAsPNG()
  }
}

35:06 - Concurrency: Explicitly offloading async work

// Explicitly offloading async work

class PhotoProcessor {
  var cachedStickers: [String: Sticker]

  func extractSticker(data: Data, with id: String) async -> Sticker {
      if let sticker = cachedStickers[id] {
        return sticker
      }

      let sticker = await Self.extractSubject(from: data)
      cachedStickers[id] = sticker
      return sticker
  }

  @concurrent
  static func extractSubject(from data: Data) async -> Sticker {}
}

- 0:00 - Introduction & Agenda
- Learn what's new in Swift 6.2. Highlights include: workflow enhancements, new library APIs, expanded adoption across the software stack, and improved concurrency language features for more productive coding.
- 0:48 - swiftlang updates
- The swiftlang organization on GitHub has grown significantly, encompassing over 50 projects, including the Swift compiler, Xcode’s build system Swift Build, and the Swift.org website. Swift Build, now open source, supports the build process for Apple operating systems, and is adopted by the Swift Package Manager. A new version manager, swiftly, originally developed for Linux, now supports macOS and simplifies Swift toolchain management. The redesigned Swift.org homepage can also help you dive into different areas.
- 3:06 - Development workflow: Writing code
- The latest Swift release enhances development workflows across all platforms, with specific improvements for VS Code Swift extension users including official verification and distribution of the Swift extension by Swift.org. Now, there's also background indexing for real-time editor features, enhanced code completion, simplified debugging with automatic LLDB support, and new project panel and live DocC previews.
- 4:40 - Development workflow: Building
- Swift 6.2 introduces several enhancements to boost your productivity. Clean build times for projects utilizing macro-based APIs are significantly improved by eliminating the need to build the swift-syntax library during clean builds. This optimization, supported by Swift PM and Xcode, can reduce build times by minutes. This release also enhances compiler diagnostics documentation by providing more detailed explanations of common warnings and errors, making them easier to understand and resolve. Additionally, you now have greater control over compiler warnings; you can specify which warnings to treat as errors, a feature driven by community feedback.
- 7:36 - Development workflow: Debugging
- Debugging is also enhanced in Swift 6.2, particularly for asynchronous code, with improved LLDB functionality, task naming and visibility in Instruments profiles. It also has faster debugger response times due to explicitly built modules enabled by default in Xcode 26.
- 9:14 - Libraries: Subprocess
- This release introduces the new Subprocess package, with which you can launch and manage subprocesses directly from Swift code. The package gives you fine-grained control over process execution, so you can specify the executable path. When the subprocess terminates, you can inspect the exit status, standard output, and other information about the process execution, with version 0.1 now available and ready for feedback.
- 10:45 - Libraries: Foundation
- The Foundation Workgroup enhanced iOS app development by introducing concrete types for notification names and payloads, streamlining code, eliminating errors, and improving thread safety for both framework and custom notifications. You can also add concrete notification types for your own notifications.
- 12:31 - Libraries: Observation
- The Observation Library in Swift uses the observer pattern to track state changes in an object graph. The 'Observable' macro enables observation tracking. Swift 6.2 introduces the 'Observations' type, with which you can create an 'AsyncSequence' to stream state changes based on a closure that computes a value from observable properties. Updates are transactional, ensuring consistent state, and you can iterate over them using a for-await loop.
- 14:13 - Libraries: Testing
- Using Swift Testing, a cross-platform library, you can write and organize tests by using macros. Swift 6.2 enhances this capability with custom attachments for better failure diagnosis, especially in remote environments, and exit tests to validate code that terminates under specific conditions. These features support testing portable Swift code, beyond just your application code.
- 16:08 - Swift throughout the stack: Embedded Swift
- Swift 6.2 enhances Embedded Swift, enabling you to write code for embedded devices, servers, and security-critical components. It now includes full-string APIs, Swift's 'any' types for class-constrained protocols, and new APIs like 'InlineArray' and 'Span' for working efficiently with regions of memory. Apple uses Embedded Swift in some of the lowest-level software on iPhone, and the community created examples available on GitHub in the swift-embedded-examples repository.
- 18:00 - Swift throughout the stack: Security
- Swift 6.2 introduces strict-memory-safety mode, an opt-in feature that requires explicit acknowledgment of unsafe API uses, aiding in identifying security-critical code sections. Apple is adopting this mode in WebKit and a Messages app subsystem, which both handle untrusted input.
- 19:37 - Swift throughout the stack: Server
- Swift is widely used in the server ecosystem, particularly at Apple, where it powers backend services processing millions of requests per second. A notable example is a password alert service, previously built in Java, which saw a 40% increase in throughput and a 50% reduction in hardware requirements after being rewritten in Swift. Other companies, such as Cultured Code, also benefited significantly from adopting Swift. The Things Cloud backend, reimplemented in Swift, experienced a 3x reduction in compute costs and a 400% improvement in average response times. Swift's growing package ecosystem, interoperability with C, Objective-C, and C++, and new open source projects like swift-java and a containerization library, enable developers to build efficient, performant server backends, and seamlessly integrate Swift with existing codebases, particularly in Java.
- 23:23 - Swift throughout the stack: Platforms
- Swift 6.2 now officially supports FreeBSD and WebAssembly (Wasm), enabling you to build client and server applications for browsers and other runtimes. The Wasm support, which started as a community project, allows you to compile Swift code and run it in the browser, as demonstrated by a 3D rendering app using WebGPU and JavaScriptKit. Swift's safety, ease of use, and performance make it an attractive choice throughout the software stack.
- 26:11 - Language evolution: Performance
- The new release also introduces two new types, 'InlineArray' and 'Span', to enhance performance of critical code. 'InlineArray' is a fixed-size array that stores elements directly, eliminating the need for heap allocation. This improves performance, especially in hot paths, and enables more optimizations like eliminating bounds checking. The system specifies the size of an 'InlineArray' as part of the type, and can infer it from array literals. 'Span' provides fast, direct access to contiguous memory without compromising memory safety. It allows functions to operate over the underlying storage of various container types, such as 'Array' and 'InlineArray', safely and efficiently. 'Span' ensures memory validity through compile-time checks, preventing common memory safety issues inherent to pointers.
- 30:28 - Language evolution: Concurrency
- Concurrency is a challenging aspect of programming due to the potential for data races when multiple tasks share memory. Swift 6 introduced data-race safety at compile time, but this often led to compiler errors when because the language would offload work to the background implicitly, even if you never needed the code to run in parallel. Swift 6.2 addresses this issue by changing the default philosophy to stay single-threaded until the you explicitly introduce concurrency. This capability, by default, makes the most natural code to write data race-free. The language now allows async functions that aren't tied to a particular actor to continue in the same actor it was called from, eliminating data races. The release also introduces isolated conformances, enabling main actor types to conform to protocols while ensuring the compiler protects main actor state. Additionally, there's now an opt-in mode to infer the main actor by default, reducing concurrency annotations in mostly single-threaded code. When you need concurrency for performance improvement, such as offloading CPU-intensive tasks to the background, Swift 6.2 provides tools to do so safely. The concurrent attribute ensures that specific functions run on the concurrent thread pool, freeing up the current actor to perform tasks simultaneously. These changes work together to make concurrency more approachable and easier to implement in Swift projects.
- 37:15 - Wrap up
- User feedback led to Swift's concurrency improvements, making it more user friendly. The community is encouraged to participate in the forums at Swift.org to continue language and ecosystem development, share projects, and stay updated on Swift-related events.

章节

资源

相关视频

WWDC25

WWDC24