RyukieDev
  • 关于我-AboutMe
  • 我的作品-MyApps
    • 「梦见」账本
      • 「梦见」账本(Umemi):极致的记账体验
      • 隐私协议:Privacy Policy
      • 服务协议:Terms of use
      • 外观预览:Preview
        • 赛博朋克-Cyberpunk
        • 樱-Sakura
        • 初恋-FirstLove
        • 永生-Eternal
        • 菲尼克斯-Phoenix
        • 报丧女妖-Banshee
        • 九霄-NYXL
        • Dream
        • 猕猴桃-Kiwi
        • 蜂蜜-Hachimitsu
        • DC
    • Elic-扫雷无尽天梯
    • 隐私访问记录
      • 03.如何分析iOS15隐私访问记录
      • PrivacyPolicy
      • FrameWorks
    • 醒词
      • PrivacyPolicy
      • TermsOfUse
    • 一色
      • PrivacyPolicy
    • 醒诗
      • PrivacyPolicy
    • 醒词键盘
      • PrivacyPolicy
    • 中文数字键盘
      • PrivacyPolicy
  • 独立开发
    • 产运
      • 01.没钱推广?这忘了这100美元
      • 02.在个人站点配置app-ads
      • 03.应用图标圆角
      • 04.iOS独立开发者注册公司到App备案上架.md
    • iCloud
      • 01.基于iCloud构建用户体系
      • 02.基于iCloud构建游戏内排行榜
  • Swift
    • 01.纯Swift路由方案探究
    • 02.使用Carthage替代CocoaPods
    • 03.逃逸闭包和非逃逸闭包
    • 04.向下向上取整
    • 05.Copy-on-write
    • 06.OC老项目Swift混编的一些坑
    • 07.OC项目中加入Swift混编
    • 08.Optional实质
    • 09.R-Swift-安全的资源组织方案forSwift
    • 10.Struct与Class
    • 11.Swift5新特性
    • 12.Swift性能分析
    • 13.SwiftPackage使用
    • 14.String与Substring
    • 15.Array,Set,Dictionary
    • 16.For-in跳跃遍历
    • 17.Switch元祖
    • 18.循环的标签控制
    • 19.Protocol与静态派发、动态派发
    • 20.Swift位移枚举
    • 21.Swift轻量级网络封装:SwiftyServiceProtocol(适用于混编或纯Swift项目)
    • 22.open与public
    • 23.Swift项目编译速度优化
    • 24.[译]编写高性能Swift代码-Writing High-Performance Swift Code(2022.8.25版)
    • 25.Swift编译流程
    • 26.Swift方法调度
  • SwiftUI
    • 01.Form
    • 02.Navigation
    • 03.ViewBuilder参数10个限制
    • 04.UIKit混编时Dismiss掉HostController
    • 05.如何在SwiftUI中使用ImagePicker?
    • 06.从some看Swift不透明类型
    • 07.TabView使用
    • 08.openURL
    • 09.Search
    • 10.SwifUI中使用WKWebView
  • DeepLearning
    • 基础知识
      • 01.感知机与神经网络
      • 02.线性可分
    • TensorFlow
      • 01.Anaconda
      • 02.JupyterNotebook
      • 03.安装TensorFlow
  • iOS
    • 底层
      • 01.alloc与字节对齐
      • 02.结构体内存对齐
      • 03.对象本质探究与isa
      • 04.ISA与Class
      • 05.深入探索Class的结构
      • 06.WWDC20-runtime优化
      • 07.深入探究属性
      • 08.isKindOfClass的底层实现
      • 09.slowpath和fastpath
      • 10.Class-cache_t
      • 11.源码解读objc_msgSend
      • 12.类的实现与初始化源码解读
      • 13.动态决议与消息转发
      • 14.iOS应用启动(一):dyld与main函数
      • 15.iOS应用启动(二):环境配置与runtime初始化
      • 16.iOS应用启动(三):镜像文件的读取和加载
      • 17.iOS应用启动(四):分类的加载
      • 18.关联对象源码解析
      • 19.MethodSwizzing方法交换的坑
      • 20.详解KVC
      • 21.KVO几个被忽视的细节
      • 22.KVO底层原理
      • 23.多线程原理与atomic
      • 24.任务与队列的几个面试题
      • 25.dispatch_once单例实现原理
      • 26.栅栏函数
      • 27.信号量
      • 28.锁|性能分析
      • 29.锁|@synchronized
      • 30.锁|递归锁
      • 31.锁|NSConditionLock
      • 32.关于Block你所该知道的一切
    • 内存管理
      • 01.从一个面试题看TaggedPointer
      • 02.Retain&Release
      • 03.SideTable和weak底层实现
      • 04.Timer优化
      • 05.自动释放池与Runloop
      • 06.dealloc
    • 编译器
      • 01.LLVM
    • 杂项
      • 01.堆栈的深度问题
      • 02.使用TTF字体
      • 03.为什么选VIPER
      • 04.项目路由方案
      • 05.隐藏导航栏下面的线
      • 06.源代码到IPA
      • 07.iOS重签名调研
      • 08.load与-initialize
      • 09.NSTimer与GCD
      • 10.NSURLConnection-和-NSURLSession
      • 11.Storyboard中UnwindSegue的使用
      • 12.UI调试-UIDebuggingInformationOverlay
      • 13.UIWebView和WKWebView
      • 14.UIWebView自适应高度
      • 15.weak实现原理
    • Runloop
      • 01.RunLoop
      • 02.autoreleasepool
    • Runtime
      • 01.基本操作
      • 02.实现NSCoding的自动归档和自动解档
      • 03.消息机制
      • 04.重写description打印对象信息
      • 05.MethodSwizzling的问题
    • 优化
      • 01.Apple官方资源瘦身方案ODR(一):初见
      • 02.Apple官方资源瘦身方案ODR(二):践行|换肤系统改造
      • 03.二进制重排实践
      • 04.iOS截屏防护方案
      • 05.提高编译速度
      • 06.图片格式-WebP
      • 07.App启动速度优化
      • 08.IDL自动化埋点
      • 09.渲染原理及优化
      • 10.「利用 Metrics 和 Diagnostics 提高性能」网络研讨活动
      • 11.离屏渲染
      • 12.一键搞定iOS16横竖屏切换
    • 多线程
      • 01.合适的线程数量
      • 02.死锁
      • 03.为什么用dispatch-once实现单例
      • 04.iOS多线程方案
      • 05.iOS多线程技术对比
    • Database
      • 01.数据库主键和外键
      • 02.FMDB-死锁问题
      • 03.FMDB与WCDB
      • 04.SQLite数据库修复
    • 架构
      • 01.组件化
  • 逆向
    • 01.寄存器
    • 03.iOS应用签名原理
    • 04.利用Xcode进行重签名与调试
    • 05.dylib注入
    • 06.MachO文件
    • 07.dyld
    • 08.Hook
    • 09.深入理解动态库与静态库
    • 10.通过符号表找到符号
    • 11.fishhook原理
    • 12.去符号与恢复符号
    • 13.反HOOK防护(一):基于Fishhook
    • 14.反HOOK防护(二):Monkey
    • 15.Inlinehook:Dobby
    • 16.LLDB
    • 17.虚拟内存
    • 18.Chisel工具
    • 19.DS.LLDB工具
    • 20.Cycript工具
    • 21.Cycrupt用法
    • 22.Logos
    • 23.应用砸壳
    • 24.实战人人视频破解
    • 25.解密被加密的数据库文件
  • Flutter
    • 01.初见Flutter
    • 02.Layout
    • 03.状态管理
    • 04.BottomNavigationBar
    • 05.MaterialApp
    • 06.android资源配置
    • 07.Positioned与Container嵌套无法充满容器
    • 08.Cell点击跳转
    • 09.代码规范
    • 10.通过联系人Cell看断言
    • 11.有状态Widget初始化重写&链式调用&排序
    • 12.索引条:手势及clamp函数
    • 13.ListView滑动到指定位置
    • 14.悬浮菜单列表
    • 15.Mock数据小技巧
    • 16.第三方库导入与网络数据异步请求与展示
    • 17.请求数据保留
    • 18.异步编程之Future
    • 19.Future&Microtask
    • 20.Dart异步编程:Isolates和事件循环
    • 21.Widget的生命周期
    • 22.Widget树&Render树&Element树
    • 23.Key
    • 24.调用原生相册
    • 25.iOS原生嵌入FlutterModule
  • 网络
    • 01 网络分层的优点
    • 02 网络理解
    • 03 iOS-网络安全之HTTPS
    • 04 POST和GET
    • 05 SSL-TLS四次握手
  • 直播技术
    • 01 直播技术相关
    • Socket-Little-Endian-Big-Endian
  • 知识点梳理
    • 01 面试算法题记录01
    • 02 面试题记录-C语言
    • 08 一套iOS底层试卷
    • 03 知识点梳理:iOS底层
    • 04 知识点梳理:网络
    • 05 知识点梳理:多线程
    • 06 知识点梳理:计算机基础
    • 07 知识点梳理:算法数据结构
    • 09 知识点梳理:HTML和浏览器
    • 10 知识点梳理:JavaSctipt
  • Framework
    • 01 CodeReading-01-YYModel
    • 02 RYImagePicker-iOS图片视频选择器
    • 03 RYImagesScroller-iOS高度自定义的图片轮播器
    • 04 RYPhotosBrowser
  • Issue
    • 01 使用KVC设置UIAlertAction按钮颜色的Crash
    • 02 iOS-常见崩溃分析
    • 03 UICollectionView的一些问题
  • OpenGL ES
    • 01.顶点着色器与片元着色器
  • 数据结构与算法
    • 剑指Offer-Swift
      • 03.找出数组中重复的数字
      • 04.二维数组中的查找
      • 05.替换空格
      • 06.从尾到头打印链表
      • 07.重建二叉树
      • 12.矩阵中的路径(回溯法)
      • 13.机器人的运动范围
      • 14.I.剪绳子
      • 14.II.剪绳子
      • 15.二进制中1的个数(含一个拓展问题)
      • 16.数值的整数次方
      • 18.删除链表的节点
      • 21.调整数组顺序使奇数位于偶数前面
      • 22.链表中倒数第k个节点
      • 24.反转链表
      • 25.合并两个排序的链表
      • 26.树的子结构
      • 27.二叉树的镜像
      • 28.对称的二叉树
      • 29.顺时针打印矩阵
      • 30.包含min函数的栈(容易被误导的一题)
      • 31.栈的压入、弹出序列
      • 32.I.从上到下打印二叉树
      • 32.II.从上到下打印二叉树II
      • 32.III.从上到下打印二叉树III
      • 32.从上到下花式打印二叉树
      • 33.二叉搜索树的后序遍历序列
      • 34.二叉树中和为某一值的路径
      • 35.复杂链表的复制(无Swift用例)
      • 36.二叉搜索树与双向链表
      • 37.序列化二叉树
      • 39.数组中出现次数超过一半的数字
      • 40.最小的k个数
      • 41.数据流中的中位数
      • 42.连续子数组的最大和
      • 43.1~n整数中1出现的次数
      • 44.数字序列中某一位的数字
      • 45.把数组排成最小的数
      • 46.把数字翻译成字符串
      • 47.礼物的最大价值
      • 48.最长不含重复字符的子字符串
      • 50.第一个只出现一次的字符
      • 52.两个链表的第一个公共节点
      • 53-I.在排序数组中查找数字
      • 53-II.0~n-1中缺失的数字
      • 54.二叉搜索树的第k大节点
      • 55-I.二叉树的深度
      • 55-II.平衡二叉树
      • 56-I.数组中数字出现的次数
      • 56-II.数组中数字出现的次数II
      • 57.和为s的两个数字
      • 58-I.翻转单词顺序
      • 58-II.左旋转字符串
      • 59-I.滑动窗口的最大值
      • 59-II.队列的最大值
      • 60.n个骰子的点数
      • 61.扑克牌中的顺子
      • 62.圆圈中最后剩下的数字
      • 63.股票的最大利润
      • 64.求1+2+…+n
      • 65.不用加减乘除做加法
      • 66.构建乘积数组
      • 67.把字符串转换成整数
      • 68-I.二叉搜索树的最近公共祖先
      • 68-II.二叉树的最近公共祖先
    • 技巧
      • 01.前缀和
      • 02.同余性质
      • 03.快速幂
      • 04.快速排序
      • 05.深度优先&广度优先
      • 06.冒泡排序
      • 07.摩尔投票
      • 08.优先队列
    • 数据结构
Powered by GitBook
On this page
  • 编写高性能的 Swift 代码
  • 一、 开启优化 - Enabling Optimizations
  • 二、 整模块优化 - Whole Module Optimizations (WMO)
  • 三、 减少动态派发 - Reducing Dynamic Dispatch
  • 动态派发 - Dynamic Dispatch
  • 建议:使用 final 当你确定被声明的不需要被重写
  • 建议:使用 private 和 fileprivate 声明不需要被文件外界访问的内容
  • 建议:如果启用了 WMO,在模块内部对不需要外部访问的内容使用 internal 关键字进行声明
  • 四、 高效的使用容器类型 - Using Container Types Efficiently
  • 建议:在数组中使用值类型
  • 建议:不需要考虑 NSArray 桥接的时候可以使用 ContiguousArray 来存储引用类型
  • 建议:使用引用修改而不是对象重新赋值 - Use inplace mutation instead of object-reassignment
  • 五、 避免检查溢出的计算 - Wrapping operations
  • 建议: 在已知不会溢出的情况下使用 wrapping arithmetic 进行不检查的整型计算 &+
  • 六、 范型 - Generics
  • 建议: 将范型声明放在需要使用它的模块内
  • 七、 Swift 中较大值类型的开销 - The cost of large Swift values
  • 建议: 较大的值类型使用写时复制 COW - Advice: Use copy-on-write semantics for large values
  • 八、 不安全的代码 - Unsafe code
  • 建议:使用非托管的引用来避免引用计数带来的开销
  • 九、 协议 - Protocols
  • 建议:将智能由 class 实现的协议标记为 class-protocol
  • 十、 left/var 被逃逸闭包捕获的性能消耗
  • 建议:如果闭包不是真的需要逃逸,使用 inout 参数传递 var
  • 补充说明 - Footnotes

Was this helpful?

  1. Swift

24.[译]编写高性能Swift代码-Writing High-Performance Swift Code(2022.8.25版)

Previous23.Swift项目编译速度优化Next25.Swift编译流程

Last updated 2 years ago

Was this helpful?

编写高性能的 Swift 代码

文中的一些 Tips 能够帮助提高 Swift 程序的质量,并提高代码容错性和可读性。

一、 开启优化 - Enabling Optimizations

首先你应该做的就是开启优化。Swift 提供了三种优化等级:

  • -Onone: 标准的开发模式。编译器提供最少的优化并且提供所有 debug 信息。

  • -O: 生产模式代码。编译器进行大量优化代码。调试信息会提供但是不完整。

  • -Osize: 一个特殊的模式,编译器会优先考虑代码大小,而不是性能。

在 Xcode 中,Project 的 Build Setting 中搜索 Optimization Level 就可以进行配置。

二、 整模块优化 - Whole Module Optimizations (WMO)

默认状态下 Swift 会独立编译每个文件。这使得 Xcode 可以快速的并行编译多个文件。但是,每个文件分开变异阻碍了编译器进行优化。Swift 也可以把整个应用程序作为一个文件进行编译,并作为一个编译单元进行优化。编译会花费更久的时间,但是 run 会更快。

Xcode 8 默认开启

三、 减少动态派发 - Reducing Dynamic Dispatch

Swift 默认是和 Objective-C 一样非常动态的语言。与 Objective-C 不同的是,Swift 给了开发者可以通过减少或者避免动态特性,来提升程序运行时性能的能力。

下面由几个例子进行说明:

动态派发 - Dynamic Dispatch

类默认对 方法调用 和 属性访问 进行动态派发。例如下面的 a.aProperty, a.doSomething() and a.doSomethingElse() 动态派发的。

  class A {
    var aProperty: [Int]
    func doSomething() { ... }
    dynamic doSomethingElse() { ... }
  }

  class B: A {
    override var aProperty {
      get { ... }
      set { ... }
    }

    override func doSomething() { ... }
  }

  func usingAnA(_ a: A) {
    a.doSomething()
    a.aProperty = ...
  }

在 Swift 里,动态派发默认是间接地通过一个 进行调用。如果在声明里加上了 dynamic 关键字,Swift 会通过 Objective-C 的消息机制进行调用。两种方式相较于直接调用函数都更慢,因为阻碍了很多 编译器可以进行 优化 的地方,间接调用也多了很多开销。想要提升代码运行性能就需要限制动态特性。

建议:使用 final 当你确定被声明的不需要被重写

final 关键字会限制 class、method、property 不能被重写。这意味着编译器可以直接调用函数,而不是间接调用。下面的 C.array1 and D.array1 将会被 直接访问 。相对的 D.array2 将会被通过一个 vtable 调用:

  final class C {
    // class 'C' 中所有声明的都不能被重写
    // No declarations in class 'C' can be overridden.
    var array1: [Int]
    func doSomething() { ... }
  }

  class D {
    // array1 不能被计算属性重写
    final var array1: [Int] // 'array1' cannot be overridden by a computed property.
    // array2 能被计算属性重写
    var array2: [Int]      // 'array2' *can* be overridden by a computed property.
  }

  func usingC(_ c: C) {
    // 访问 C.array1 不会经过动态派发
    c.array1[i] = ... // Can directly access C.array without going through dynamic dispatch.
    // 会直接调用 C.doSomething 不会经过虚函数表调用
    c.doSomething() = ... // Can directly call C.doSomething without going through virtual dispatch.
  }

  func usingD(_ d: D) {
    // 直接访问 D.array1 不经过动态派发
    d.array1[i] = ... // Can directly access D.array1 without going through dynamic dispatch.
    // 经过动态派发访问 D.array2
    d.array2[i] = ... // Will access D.array2 through dynamic dispatch.
  }

建议:使用 private 和 fileprivate 声明不需要被文件外界访问的内容

使用 private 和 fileprivate 关键字能够将这些声明的访问限制在该文件内部。这会让编译器能查出所有其它潜在的重写声明。由此编译器能够自动推断 final 关键字并删除方法的间接调用和空间访问。

如下:假设 E, F 在该文件内没有重写任何声明,那么 e.doSomething() 和 f.myPrivateVar 就能够被直接访问:


  private class E {
    func doSomething() { ... }
  }

  class F {
    fileprivate var myPrivateVar: Int
  }

  func usingE(_ e: E) {
    /**
    该文件内没有子类存在
    编译器可以移除 doSomething 的虚表调用,并直接调用 E 的 doSomething 方法
    */
    e.doSomething() // There is no sub class in the file that declares this class.
                    // The compiler can remove virtual calls to doSomething()
                    // and directly call E's doSomething method.
  }

  func usingF(_ f: F) -> Int {
    return f.myPrivateVar
  }

建议:如果启用了 WMO,在模块内部对不需要外部访问的内容使用 internal 关键字进行声明

WMO 使得编译器将整个模块的代码作为一个整体一次性进行编译。使编译单个声明时能够拥有更广的视野从而进行优化。当一个声明为 internal 就不会在模块外部被访问到,优化器可以根据是否存在潜在的声明重写,而自动推断出 final 关键字。

NOTE: 由于现在 Swift 默认的访问级别已经是 internal,通过开启 WMO 就不用额外的操作(WMO 也是默认开启的了)。

四、 高效的使用容器类型 - Using Container Types Efficiently

Swift 标准库提供了重要功能:通用容器 Array 和 Dictionary。下面将介绍如何高效的使用这些类型。

建议:在数组中使用值类型

在 Swift 中,类型能够被分为两种:值类型 (structs, enums, tuples),引用类型 (classes)。一个关键的差别是值类型不能被放入 NSArray。因此当使用值类型时,优化器就不需要去处理对 NSArray 的兼容。

并且对比引用类型,值类型仅当包含了引用类型的时候才需要引用计数。通过使用不包含引用类型的值类型,可以避免在 Array 内部的 retain 和 release 减少开销。


  // Don't use a class here.
  struct PhonebookEntry {
    var name: String
    var number: [Int]
  }

  var a: [PhonebookEntry]

需要时刻注意平衡使用大的值类型和引用类型。有时拷贝移动一个巨大的值类型可能消耗比管理一个引用类型的 retain/release 消耗还要大。

建议:不需要考虑 NSArray 桥接的时候可以使用 ContiguousArray 来存储引用类型


  class C { ... }
  var a: ContiguousArray<C> = [C(...), C(...), ..., C(...)]

Array 需要考虑对 NSArray 的兼容,内部存在很多类型检查。

建议:使用引用修改而不是对象重新赋值 - Use inplace mutation instead of object-reassignment

在 Swift 标准库中所有的容器类型都是使用了 COW(copy-on-write) 机制来替代直接拷贝。在大多数情况下,编译器会引用容器而不是深拷贝。只有当容器的引用计数大于 1 并且容器被修改了,才会触发底层容器的拷贝。

如下:当 c 赋值给 d,不会触发拷贝。但是当 d 通过 append(2) 修改的时候,d 会先拷贝容器,然后 2 会被添加进 d:

  var c: [Int] = [ ... ]
  var d = c        // No copy will occur here.
  d.append(2)      // A copy *does* occur here.

如果使用不当,COW 有时会造成没必要的拷贝。例如下面的例子通过在方法内部返回一个新数组,进行对象重新赋值来达到 append_one。所有传入的参数都会被 reatin 然后在函数结束后 release。如果像下面这样实现一个 append_one 方法:

  func append_one(_ a: [Int]) -> [Int] {
    var a = a
    a.append(1)
    return a
  }

  var a = [1, 2, 3]
  a = append_one(a)

a 可能会被拷贝,尽管 a 在 append_one 结束后没有被使用。如果使用 inout 就可以避免:

  func append_one_in_place(a: inout [Int]) {
    a.append(1)
  }

  var a = [1, 2, 3]
  append_one_in_place(&a)

五、 避免检查溢出的计算 - Wrapping operations

Swift 在执行一般整型计算的时候会检查是否溢出。但是在已知不会溢出的场景下依旧这么做就显得非常不合适了,也不符合高性能编码的期望。

建议: 在已知不会溢出的情况下使用 wrapping arithmetic 进行不检查的整型计算 &+

在高性能编码中,如果你确定不会溢出,就可以使用 wrapping arithmetic 来避免检查。

  a: [Int]
  b: [Int]
  c: [Int]

  // Precondition: for all a[i], b[i]: a[i] + b[i] either does not overflow,
  // or the result of wrapping is desired.
  for i in 0 ... n {
    c[i] = a[i] &+ b[i]
  }

需要指出的是,&+ &- &* 在溢出的时候结果会简单的处理。例如:Int.max &+ 1 的结果是 Int.min(不像C语言里,INT_MAX + 1 是为无法定义的操作)。

六、 范型 - Generics

Swift 通过范型提供了非常强大的抽象能力。Swift 编译器通过 MySwiftFunc<T> 生成可以为 T 执行的代码块。生成的代码块包含一个函数指针列表和一个包含 T 容器作为参数。MySwiftFunc<Int> 和 MySwiftFunc<String> 的不同表现,是通过传递不同的函数列表和容器大小来决定的。一个范型例子:

  class MySwiftFunc<T> { ... }

  // 生成为 Int 工作的代码
  MySwiftFunc<Int> X    // Will emit code that works with Int...
  // 生成为 String 工作的代码
  MySwiftFunc<String> Y // ... as well as String.

当开启了优化,Swift 编译器会检查每个调用调用,并检查其中使用的类型(比如非范型类型)。如果范型函数的定义对优化器是可见的并且类型是已知的,Swift 编译器将会生成一个针对这个特定类型版本的函数。这个过程叫做 specialization(定制化),可以避免一些范型相关的消耗。如下例子:

  class MyStack<T> {
    func push(_ element: T) { ... }
    func pop() -> T { ... }
  }

  func myAlgorithm<T>(_ a: [T], length: Int) { ... }

  // The compiler can specialize code of MyStack<Int>
  // 编译器会为范型 MyStack<Int> 生成特定代码
  var stackOfInts: MyStack<Int>

  // Use stack of ints.
  for i in ... {
    stack.push(...)
    stack.pop(...)
  }

  var arrayOfInts: [Int]
  // The compiler can emit a specialized version of 'myAlgorithm' targeted for
  // [Int]' types.
  // 编译器会生成针对 [Int] 版本的函数
  myAlgorithm(arrayOfInts, arrayOfInts.length)

建议: 将范型声明放在需要使用它的模块内

优化器只能对声明在当前模块中的范型定义进行特化处理。如果 WMO 没有开启,即只会当声明和调用在同一个文件的时候才会处理。

NOTE: 标准库是个特例。定义在标准库中的对所有模块可见并可以被特化处理。

七、 Swift 中较大值类型的开销 - The cost of large Swift values

在 Swift 中,一些较大的值类型如果进行拷贝会比较耗时,并影响性能。

下面使用值类型定义了一个 Tree。其节点包含了其他同样遵守 P协议 的节点。计算机图形场景下经常由可以用值类型表示的不同的实体entities和变体transformations构成。


  protocol P {}
  struct Node: P {
    var left, right: P?
  }

  struct Tree {
    var node: P?
    init() { ... }
  }

当一个 tree 被拷贝,真个 tree 都要被拷贝。这里对于我们的 tree 来说是一个开销很大的操作,需要大量的执行 malloc/free 并校验引用计数。

然而我们并不关心这些值是否被拷贝,只要它还在内存中可以被正常使用。

建议: 较大的值类型使用写时复制 COW - Advice: Use copy-on-write semantics for large values

写时复制能够解决值类型大量拷贝的问题。实现写时拷贝最简单的方式就是使用现成的 COW 数据结构,比如 Array。Swift 的 Array 是值类型。但是 Array 的内容不会每次都拷贝,因为使用来写时复制。

我们使用 Array 改造 Tree 可以避免大量的拷贝操作。这提升了 Tree 数据结构的性能表现,并且将传递一个数组的时间复杂度由O(n)降低到了O(1)。

  struct Tree: P {
    var node: [P?]
    init() {
      node = [thing]
    }
  }

使用数组来实现 COW 机制有两个明显的缺点:

  • 第一个问题就是数组中类似 "append" 和 "count" 的方法,它们在值封装中没有任何作用。这些方法让引用封装变得很不方便。我们可以通过创建一个隐藏未用到的 API 的封装结构来解决这个问题,并且优化器会移除它的开销,但是这样的封装并不能解决第二个问题。

  • 第二个问题就是数组内存在保证程序安全性和与 Objective-C 进行交互的代码, Swift 会检查索引访问是否在数组边界内,以及保存值时会判断数组存储时否需要扩展存储空间。这些操作运行时都会降低程序速度。

一个替代方法就是实现一个 copy-on-write 机制的数据结构来代替数组作为值封装。下面的例子就是介绍如何构建一个这样的数据结构:

final class Ref<T> {
  var val: T
  init(_ v: T) { val = v }
}

struct Box<T> {
  var ref: Ref<T>
  init(_ x: T) { ref = Ref(x) }

  var value: T {
    get { return ref.val }
    set {
      if !isKnownUniquelyReferenced(&ref) {
        ref = Ref(newValue)
        return
      }
      ref.val = newValue
    }
  }
}

Box 类型可以代替上个例子中的数组。

八、 不安全的代码 - Unsafe code

Swift 中类总是采用引用计数。 Swift 编译器会在每次对象被访问时插入增加引用计数的代码。例如,考虑一个通过使用类实现遍历链表的例子。遍历链表是通过从一个节点到下一个节点移动引用实现: elem = elem.next。每次我们移动这个引用, Swift 将会增加 next 对象的引用计数,并且减少前一个对象的引用计数。这样的引用计数方法成本很高,但只要我们使用 Swift 的类就无法避免。


  final class Node {
    var next: Node?
    var data: Int
    ...
  }

建议:使用非托管的引用来避免引用计数带来的开销

Note: Unmanaged<T>._withUnsafeGuaranteedRef 不是公开的 API,并且今后将会被移除。所以不要使用它。

在性能优先代码中,你可以选择使用未托管的引用。其中 Unmanaged<T> 结构体就允许开发者关闭对于特殊引用的自动引用计数 (ARC) 功能。

当你这样做了,你需要确保有另外的引用引用这个被 Unmanaged 的实例,来保证在使用 Unmanaged 期间实例不会释放。


  // The call to ``withExtendedLifetime(Head)`` makes sure that the lifetime of
  // Head is guaranteed to extend over the region of code that uses Unmanaged
  // references. Because there exists a reference to Head for the duration
  // of the scope and we don't modify the list of ``Node``s there also exist a
  // reference through the chain of ``Head.next``, ``Head.next.next``, ...
  // instances.

  withExtendedLifetime(Head) {

    // Create an Unmanaged reference.
    var Ref: Unmanaged<Node> = Unmanaged.passUnretained(Head)

    // Use the unmanaged reference in a call/variable access. The use of
    // _withUnsafeGuaranteedRef allows the compiler to remove the ultimate
    // retain/release across the call/access.

    while let Next = Ref._withUnsafeGuaranteedRef { $0.next } {
      ...
      Ref = Unmanaged.passUnretained(Next)
    }
  }

九、 协议 - Protocols

建议:将智能由 class 实现的协议标记为 class-protocol

Swift 可以限定协议只能通过类实现。标记协议只能由类实现的一个优点就是,编译器可以基于只有类实现协议这一事实来优化程序。

例如,如果 ARC 内存管理系统知道正在处理类对象,那么就能够简单的保留(增加对象的引用计数)它。如果编译器不知道这一事实,它就不得不假设结构体也可以实现协议,那么就需要准备保留或者释放不可忽视的结构体,这样做的代价很高。

如果限定只能由类实现某个协议,那么就需要标记类实现的协议为类协议,以便获得更好的运行性能。

  protocol Pingable: AnyObject { func ping() -> Int }

十、 left/var 被逃逸闭包捕获的性能消耗

可能很多人认为 let 和 var 的区别仅仅是语义层面的,起始其中也有性能方面的思考。一旦一个变量和一个闭包发生了绑定,就强制编译器生成一个逃逸闭包。例如:

  let f: () -> () = { ... } // Escaping closure
  // Contrasted with:
  ({ ... })() // Non Escaping closure
  x.map { ... } // Non Escaping closure

当一个 var 被逃逸闭包捕获,编译器必须在堆上开辟空间来存储这个 var 使得,创建者和闭包都能够读写这个 var。相对的当捕获一个 let。会直接在闭包的数据结构内添加一个该变量的 copy,而不用去堆上开辟空间。

建议:如果闭包不是真的需要逃逸,使用 inout 参数传递 var

inout 会确保不会在堆上再去开辟空间,避免了没必要的 retain/release 操作。

补充说明 - Footnotes

  1. This is due to the compiler not knowing the exact function being called.

  2. An optimization technique in which a copy will be made if and only if a modification happens to the original copy, otherwise a pointer will be given.

Note: 这样的解决办法,对于嵌套结构并非最优,并且一个基于 COW 数据结构的 addressor 会更加高效。然而在这种情况下,抛开标准库执行 addressor 是行不通的。

Whole-Module Optimization in Swift 3
Swift标准库源码阅读笔记 - Array和ContiguousArray
More on value types
面向协议编程 Protocol-Oriented-Programming
More details in this blog post by Mike Ash
Unmanaged.swift
Unmanaged
Protocols