Swift --- 記憶體管理

• 跟OC一樣，Swift也是采取基于引用技術的ARC記憶體管理方案（針對堆空間）
• Swift的ARC中有3中引用：

1. 強引用（strong reference）：預設情況下，引用都是強引用
2. 弱引用（weak reference）：通過weak定義弱引用

• 必須是可選類型的var，因為實力銷毀後，ARC戶自動将弱引用設定為nil

  ARC自動給弱引用設定nil時，不會觸發屬性觀察器

1. 無主引用（unowned reference）：通過unowned定義無主引用

• 不會産生強引用，執行個體銷毀後任然存儲着執行個體的記憶體位址（類似于OC中的unsafe_unretained）
• 視圖在實力銷毀後通路無主引用，會産生運作時錯誤（野指針）
• Fatal error：Attempted to read an unowned reference but object 0x0 was already deallocated

weak、unowned的使用限制

• weak、unowned隻能用在類執行個體上面

protocol Livable: AnyObject {}
class Person {}

weak var p0: Person?
weak var p1: AnyObject?
weak var p2: Livable?

unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Livable?
           

Autoreleasepool

autoreleasepool {
    let p = MyPerson(age: 20, name: "Jack")
    p.run()
}
           

循環引用（Reference Cycle）

• weak、unowned都能解決循環引用的問題，unowned要比weak少一些性能消耗
• 在聲明周期中可能會變為nil的使用weak
• 初始化指派後再也不會變為nil的使用unowned

  

閉包的循環引用

• 閉包表達式預設回對用到的外層對象産生額外的強引用（對外層對象進行了retain操作）
• 下面代碼會産生循環引用，導緻Person對象無法釋放（看不到Person的deinit被調用）

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    p.fn = { p.run() }
}
test()
``
- 在閉包表達式的捕獲清單聲明weak或者unowned引用，解決循環引用問題
```swift
p.fn = {
    [weak p] in
    p?.run()
}
p.fn = {
    [unowned p] in
    p.run()
}
p.fn = {
    [weak wp = p, unowned up = p, a = 10 + 20] in 
    wp?.run()
}
           

• 如果想在定義閉包屬性的同僚引用self，這個閉包必須是lazy的（因為在初始化完畢之後才能引用self）
• 下面的閉包fn内部如果用到了執行個體成員（屬性、方法）
• 編譯器會強制要求明确寫出self

class Person {
    lazy var fn: (() -> ()) = {
        [weak self] in
        self?.run()
    }
    func run() { print("run") }
    deinit { print("deinit") }
}
           

• 如果lazy屬性是閉包調用的結果，那麼不用考慮循環引用的問題（因為閉包調用後，閉包的生命周期就結束了）

class Person {
    var age: Int = 0
    lazy var getAge: Int = {
      self.age  
    }()
    deinit { print("deinit") }
}
           

@escaping

• 非逃逸閉包、逃逸閉包，一般都是當做參數傳遞給函數
• 非逃逸閉包：閉包調用發生在函數結束前，閉包調用在函數作用域内
• 逃逸閉包：閉包有可能再函數結束後調用，閉包調用逃離了函數的作用域，需要通過@escaping聲明

import Dipatch
typealias Fn = () -> ()
           

// fn是非逃逸閉包
func test1(_ fn: Fn) { fn() }
           

// fn是逃逸閉包
var gFn: Fn ?
func test2(_ fn: @escaping Fn) { gFn = fn }
           

// fn是逃逸閉包
func test3(_ fn: @escaping Fn) {
    DispatchQueue.global().async {
        fn()
    }
}
           

class Person {
    var fn: Fn
    // fn是逃逸閉包
    init(fn: @escaping Fn) {
        self.fn = fn
    }
    func run() {
        // DispatchQueue.global().async也是一個逃逸閉包
        // 它用到了執行個體成員（屬性、方法），編譯器會強制要求明确寫出self
        DispatchQueue.global().async {
            self.fn()
        }
    }
}
           

記憶體通路沖突

• 記憶體通路沖突會在兩個通路滿足下列條件時發生：

1. 至少一個是寫入操作
2. 它們通路的是同一塊記憶體
3. 它們的通路時間重疊（比如在同一個函數内）

// 不存在記憶體沖突
func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number)
           

// 存在記憶體通路沖突
// Simulaneous accesses to 0x0, bu modificaiton require exclusive access
var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step)
           

// 解決記憶體通路沖突
var copyOfStep = step
increment(&copyOfStep)
step = copyOfStep
           

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
var num1 = 42
var num2 = 30
balance(&num1, &num2) // OK
balance(&num1, &num1) // Error
           

struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}
var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria) // OK
oscar.shareHealth(with: &oscar) // Error
           

var tulpe = (health: 10, energy: 20)
// Error
balance(&tulpe.health, &tulpe.energy)

var holly = Player(name: "Holly", health: 10, energy: 10)
// Error
balance(&holly.health, &holly.energy)
           

• 如果下面的條件可以滿足，就說明重疊通路結構體的屬性是安全的

1. 你隻通路執行個體存儲屬性，不是計算屬性或者類型屬性
2. 結構體是局部變量而非全局變量
3. 結構體要麼沒有被閉包捕獲要麼隻被非逃逸閉包捕獲

// OK
func test() {
    var tulpe = (health: 10, energy: 20)
    balance(&tulpe.health, &tulpe.energy)
    
    var holly = Player(name: "Holly", health: 10, energy: 10)
    balance(&holly.health, &holly.energy)
}
test()