Swift - Automatic Reference Counting

Swift 和 OC 的 ARC 很相似

ARC 工作原理

创建一个类的实例，ARC 为实例分配内存
当类不再需要，ARC 释放内存并能为其他地方使用。确保实例不再需要时不会消耗内存
如果还在使用 ARC 释放的实例，将不能访问该实例属性或方法，并且很可能会引起崩溃
分配一个类实例到属性、常量、变量，它们将会强引用实例。只要强引用存在，它将不会被释放

Code For Strong Reference

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

var reference1: Person?
var reference2: Person?
var reference3: Person?

// 三个强引用
reference1 = Person(name: "Reference") 
reference2 = reference1
reference3 = reference1

reference1 = nil
reference2 = nil
// 这时候 Person 还没有释放，还剩下最后一个强引用

// 被释放，调用 deinit 
reference3 = nil

解决循环引用的三种方法

weak reference
unowned reference
unowned reference & unwrapped optional property

Weak Reference

场景：两个实例变量均保持各自的强引用

强引用

john (strong) Person instance && unit4A (strong) Apartment instance
john.apartment (strong) Apartment instance && unit4A.tenant (strong) Person instance
john 和 unit4A 引用计数均为 2
当 john = nil，Person instance 引用计数为 1，Apartment instance 依旧持有 Person instance
当 unit4A = nil，Apartment instance 引用计数为 1，Person instance 依旧持有 Apartment instance
Apartment instance 和 Person instance 相互持有

弱引用

john (strong) Person instance && unit4A (strong) Apartment instance
john.apartment (strong) Apartment instance && unit4A.tenant (weak) Person instance
john 引用计数为 1、unit4A 引用计数为2
当 john = nil，john 引用计数为 0，Apartment instance 弱引用 Person instance，Person instance 释放
unit4A.tenant = nil，unit4A 引用计数为 1
当 unit4A = nil，unit4A 引用计数为 0，Apartment instance 释放

weak feature

weak 修饰属性实例的生命周期比持有属性的实例生命周期短
weak 关键字修饰属性或变量
weak 引用实例释放，置nil，所以修饰对象为可选变量
ARC 下 weak 引用置 nil，属性观察者不会被调用
在垃圾回收系统中，弱指针有时候被用于实现简单的缓存机制，因为只有当内存压力触发垃圾回收时，没有强引用的对象才会被释放。但是在 ARC 中，实例在最后一个强引用被移除后就被释放。（疑惑：下面代码实际执行后，发现并没有立即释放）

Apartment 可以没有房客，所以对应的 tenant 可以优先被释放

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    // Weak Reference
    weak var tenant: Person?
    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

// Optional
var john: Person? 
var unit4A: Apartment?

john = Person(name: "Person")
unit4A = Apartment(unit: "unit4A")

// 强制解包
john!.apartment = unit4A
unit4A!.tenant = john

john = nil
unit4A = nil

Unowned Reference

像 Weak Reference 一样不会强保持一个实例
修饰属性实例比持有属性的实例有相同或更长生命周期
ARC 下 Unowned Reference 不会被置 nil，即不能定义为 Optional
对已释放的实例尝试访问，会导致报错

无主引用

customer (strong) CreditCard instance
customer.card (strong) CreditCard instance && (CreditCard instance).customer (unowned) Customer instance
customer 引用计数为 1
当 customer = nil，customer 引用计数为 0 释放，CreditCard instance 也没有强引用释放

CreditCard 必须依赖一个 Customer，Customer 可以没有 CreditCard

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

class CreditCard {
      // 为了满足在 32 和 64 位系统中有足够大内存存储 16 位数字
      // 是 UInt64 而不是 Int

//     Int16 等于 short，占用 2 个字节，-32768 ~ 32767
//     Int32 等于 int，占用 4 个字节，-2147483648 ~ 2147483647
//     Int64 等于 long，占用 8 个字节，-9223372036854775808 ~ 9223372036854775807
//     Int8 占用 1 个字节
        
      let number: UInt64
      // unowned reference
      unowned let customer: Customer
      init(number: UInt64, customer: Customer) {
            self.number = number
            self.customer = customer
      }
      deinit {
          print("Card #\(number) is being deinitialized")
      }
}

var customer: Customer? 
customer = Customer(name: "Customer")
customer!.card = CreditCard(number: 1234_5678_9012_3456, customer: customer!)
customer = nil

unsafe unowned reference

不需要运行时安全检查时使用，例如性能优化，但是需要检查代码安全
unowned(unsafe) 修饰
不安全操作：如果尝试访问一个被 unowned(unsafe) 引用且释放了实例，程序将会访问实例被使用的内存位置

闭包循环引用

避免闭包循环引用，添加 capture list
Swift 要求在闭包中写 self.someProperty 而不是 someProperty，时刻提醒该位置是有捕获 self 的

以下是引起循环引用的代码示例

class HTMLElement {
     let name: String
     let text: String?
      
     // 闭包
     lazy var asHTML: () -> String = {
          if let text = self.text {
                return "<\(self.name)>\(text)<\(self.name)>"
         } else {
               return "<\(self.name) />"
         }
     }

     init(name: String, text: String? = nil) {
          self.name = name
          self.text = text
     }

     deinit {
          print("\(name) is being deinitialized")
     }
}

capture list 中的 weak 和 unowned

unowned: 互相持有，将在同一时间释放（如果 reference 永不为 nil，使用 unowned）
weak: weak reference 在未来某个时刻会 nil，weak reference 总是可选类型

以下是解决循环引用的代码示例

class HTMLElement {
     let name: String
     let text: String?
      
    lazy var asHTML: () -> String = {
        [unowned self]
        if let text = self.text {
            return "<\(self.name)>\(text)<\(self.name)>"
       } else {
            return "<\(self.name) />"
       }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

其他示例

lazy var someClosure: (int, String) -> String = {
      [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> in
      // body
}

lazy var someClosure: () -> String = {
      [unowned self, weak delegate = self.delegate!] in
      // body
}