编写高性能 Swift - 减少动态分发的三条建议

发表于 3年以前 | 总阅读数：256 次

高性能代码是每个开发工程师应有的追求。

在 Swift 官方 Github 上，官方整理了一些编写高性能 Swift 代码的技巧，这些技巧可以帮助提高您的Swift程序的质量，并使代码更不易出错，更易读。值得我们好好研读。

小集后续会陆续整理这些内容，同时也会搜集这一类的好文章，期望能给 Swifter 带来帮助。

Swift 与 Objective-C 一样，是一种高度动态化的语言。不过与 Objective-C 不同的是，Swift 能够在必要时通过消除或减少这种动态性来提高运行时性能。本节将介绍几个可用于执行这类操作的语言构造。

动态分发

默认情况下，Swift 中类的方法和属性访问使用动态分发的方式。因此，在下面的代码段中，a.aProperty、a.doSomething() 和 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 中，动态分发默认通过 vtable 来间接调用。如果在声明中附加 dynamic 关键字，那么 Swift 将以 Objective-C 消息分发机制来发出调用。这两种情况都比直接函数调用的方式慢，因为它们除了执行间接调用本身的开销外，还阻止了许多编译器优化。

所以，在对性能很敏感的应用中，我们通常会希望限制这种动态行为。

建议1：当知道不需要重写声明时，请使用 final

final 关键字是对类、方法或属性的声明的限制，以使声明不能被覆盖。这意味着编译器可以使用直接函数调用，而不是间接调用。例如，在下面的示例中，将直接访问 C.array1 和 D.array1。相比之下，D.array2 将通过 vtable 进行调用：

final class C {
  // No declarations in class 'C' can be overridden.
  var array1: [Int]
  func doSomething() { ... }
}

class D {
  final var array1: [Int] // 'array1' cannot be overridden by a computed property.
  var array2: [Int]      // 'array2' *can* be overridden by a computed property.
}

func usingC(_ c: C) {
   c.array1[i] = ... // Can directly access C.array without going through dynamic dispatch.
   c.doSomething() = ... // Can directly call C.doSomething without going through virtual dispatch.
}

func usingD(_ d: D) {
   d.array1[i] = ... // Can directly access D.array1 without going through dynamic dispatch.
   d.array2[i] = ... // Will access D.array2 through dynamic dispatch.
}

建议2：当不需要在文件外部访问声明时，请使用 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) {
  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
}