Swift

• 原文博客地址: 淺談Swift的內(nèi)存管理
• 2020年的第一篇博客, 算是2020年開了個好頭, 希望能夠繼續(xù)堅(jiān)持下去, 繼續(xù)記錄分享更多更高質(zhì)量的文章
• 今年期待已久的Swift5.0穩(wěn)定版就已經(jīng)發(fā)布了, 感興趣的小伙伴可看我的這篇博客:Swift 5.0新特性更新
• 這篇博客可主要分享Swift的內(nèi)存管理的相關(guān)介紹和剖析, 測試環(huán)境: Xcode 11.2.1, Swift 5.1.2

內(nèi)存管理

• 和OC一樣, 在Swift中也是采用基于引用計數(shù)的ARC內(nèi)存管理方案(針對堆空間的內(nèi)存管理)
• 在Swift的ARC中有三種引用
  • 強(qiáng)引用(strong reference)：默認(rèn)情況下，代碼中涉及到的引用都是強(qiáng)引用
  • 弱引用(weak reference)：通過weak定義弱引用
  • 無主引用(unowned reference)：通過unowned定義無主引用

weak

• 弱引用(weak reference)：通過weak定義弱引用
  • 必須是可選類型的var，因?yàn)閷?shí)例銷毀后，ARC會自動將弱引用設(shè)置為nil
  • ARC自動給弱引用設(shè)置nil時，不會觸發(fā)屬性觀察
• 在介紹weak弱引用之前, 先看一下下面一段代碼

class Animal {
    deinit {
        print("Animal deinit")
    }
}

func test() {
    let animal = Animal()
}

print("will deinit")
test()
print("did deinit")

上面這段代碼中在test函數(shù)調(diào)用結(jié)束之后, 該作用的內(nèi)存就會被回收, animal對象自然就會被銷毀, 毫無疑問上面的輸出結(jié)果應(yīng)該是

will deinit
Animal deinit
did deinit

同樣下面這段代碼, 同樣也是在a1對象被置為nil的時候內(nèi)存會被回收, 對象就會被銷毀

var a1: Animal? = Animal()
print("will deinit")
a1 = nil
print("did deinit")

• 下面是一個被weak修飾的弱引用對象,
• 我們都知道, 被weak修飾的弱引用對象, 在對象銷毀的時候, 會被自動置為nil
• 所以被weak修飾的弱引用對象必須是可選類型的var, 兩個條件缺一不可

weak var a2: Animal? = Animal()

// 以下兩種方式都會報錯的
weak var a2: Animal = Animal()
weak let a2: Animal? = Animal()

unowned

• 無主引用(unowned reference)：通過unowned定義無主引用
• 不會產(chǎn)生強(qiáng)引用，實(shí)例銷毀后仍然存儲著實(shí)例的內(nèi)存地址(類似于OC中的unsafe_unretained）
• 試圖在實(shí)例銷毀后訪問無主引用，會產(chǎn)生運(yùn)行時錯誤（如下野指針)

Fatal error: Attempted to read an unowned reference but object 0x0 was already deallocate

另外需要注意的是, weak、unowned只能用在類實(shí)例上面, 如下所示

// 該協(xié)議表示只能被類遵守, AnyObject代表所有的類實(shí)例
protocol Liveable: AnyObject {}
class Person {}

weak var p0: Person?
weak var p1: AnyObject?
// 所有能遵循Liveable協(xié)議的肯定都是類
weak var p2: Liveable?

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

循環(huán)引用

• weak、unowned都能解決循環(huán)引用的問題，unowned要比weak少一些性能消耗
• 在生命周期中可能會變?yōu)?code>nil的使用weak
• 初始化賦值后再也不會變?yōu)?code>nil的使用unowne
• 說道循環(huán)引用就自然想到了閉包

閉包的循環(huán)引用

閉包表達(dá)式默認(rèn)會對用到的外層對象產(chǎn)生額外的強(qiáng)引用（對外層對象進(jìn)行了retain操作）, 看一下下面的代碼中deinit會被調(diào)用嗎?

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}

func test() {
    let p = Person()
    p.fn = { 
        p.run()
    }
}

test()

• 上面代碼中, p對象強(qiáng)引用著fn閉包, fn閉包也強(qiáng)引用著p對象, 自然就造成了循環(huán)引用問題
• 最后沒有任何輸出結(jié)果, 我們看一下上述代碼的匯編執(zhí)行過程

weak

• 從上面匯編代碼可以看出, 整個過程經(jīng)歷了
• 一次init引用計數(shù)為----1
• 一次retain引用計數(shù)會加(1), 結(jié)果為----2
• 一次release引用計數(shù)會減(1), 結(jié)果為----1
• 那么最后的引用計數(shù)就是1, 所以p對象肯定沒有被釋放
• 下面是使用解決循環(huán)引用的情況
  • 在閉包表達(dá)式的捕獲列表里, 聲明weak或unowned引用，用以解決循環(huán)引用問題

// 使用weak
func test() {
    let p = Person()
    p.fn = { [weak p] in
        p?.run()
    }
}

// 使用unowned
func test() {
    let p = Person()
    p.fn = { [unowned p] in
        p.run()
    }
}

• 上述兩種方式都可以解決循環(huán)引用的問題, 運(yùn)行后就發(fā)現(xiàn)Person對象調(diào)用了deinit
• 這里我們再看一下匯編代碼如下, 從下面匯編代碼中可以很明顯看到, 引用計數(shù)最后為0, 對象被釋放

weak

另外下面這段代碼其實(shí)是等價的

func test() {
    let p = Person()
    p.fn = { [unowned p] in
        p.run()
    }
}

// 和上面等價代碼
func test() {
    let p = Person()
    p.fn = { [unowned ownedP = p, weak weakP = p] in
        ownedP.run()
        // weakP?.run()
    }
}

特別注意點(diǎn), 這里要區(qū)分捕獲列表和參數(shù)列表, 下面看看fn有參數(shù)的情況下

class Person {
    var fn: ((Int) -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}

func test() {
    let p = Person()
    p.fn = {
        (num) in
        print("num = \(num)")
    }
}

那么閉包的參數(shù)列表和捕獲列表同事存在的情況如下代碼所示

func test() {
    let p = Person()
    p.fn = {
        [weak p](num) in
        print("num = \(num)")
        p?.run()
    }
}

self的循環(huán)引用

• 如果想在引用閉包的同時引用self, 這個閉包必須是lazy的
• 因?yàn)閷?shí)例在初始化完畢之后才能引用self

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

func test() {
    let p = Person()
    p.fn()
}

test()

• 上面代碼中如果fn閉包去掉lazy, 編譯器會直接報錯
• 在Swift中, 為了保證初始化的安全, 設(shè)定了兩段式初始化, 在所有的存儲屬性被初始化完成之后, 初始化器才能夠使用self
• 而且在上述fn閉包中, 如果fn內(nèi)部用到了實(shí)例成員(屬性和方法), 則編譯器會強(qiáng)制要求明確寫出self
• lazy既保證只有在使用的時候才會被初始化一次
• 但是上述代碼同樣存在循環(huán)引用的問題, Person對象強(qiáng)引用著fn閉包, fn閉包也強(qiáng)引用著self
• 同樣使用weak和unowned解決循環(huán)引用的問題

// weak解決循環(huán)引用
lazy var fn: (() -> ()) = {
    [weak self] in
    self?.run()
}

// unowned解決循環(huán)引用
lazy var fn: (() -> ()) = {
    [unowned self] in
    self.run()
}

另外再看看下面這種情況, 是都存在循環(huán)引用的問題

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

func test() {
    let p = Student()
    print(p.getAge)
}

test()

/* 輸出結(jié)果
2
deinit
*/

通過輸出結(jié)果看一看出調(diào)用了deinit, 說明對象最終被釋放, 并未出現(xiàn)循環(huán)引用的問題, 下面比較一下

// 存在循環(huán)引用
class Person {
    lazy var fn: (() -> ()) = {
        self.run()
    }
    func run() { print("run") }
    deinit { print("deinit") }
}

// 不存在循環(huán)引用
class Student {
    var age: Int = 2
    lazy var getAge: Int = {
        self.age
    }()
    deinit { print("deinit") }
}

• 上述兩種寫法的區(qū)別, 本質(zhì)上說
• Person對象中的fn閉包屬于閉包賦值
• Student對象那個中的getAge屬于閉包調(diào)用(類似函數(shù)調(diào)用)
• 相當(dāng)于在在Student對象調(diào)用getAge結(jié)束之后, 作用域內(nèi)的變量就會被釋放

// getAge也可以寫成如下形式
lazy var getAge: Int = {
    return self.age
}()

// 也可以理解為
lazy var getAge: Int = self.age

內(nèi)存訪問沖突

在Swift中的內(nèi)存訪問沖突主要在兩個訪問滿足下列條件時發(fā)生

• 至少一個是寫入操作
• 它們訪問的是同一塊內(nèi)存
• 它們的訪問時間重疊(比如在同一個函數(shù)內(nèi))
• 對比看看以下兩個函數(shù)操作

// 不存在內(nèi)存訪問沖突
var number = 1
func plus(_ num: inout Int) -> Int {
    return num + 1
}
number = plus(&number)

// 存在內(nèi)存訪問沖突
var step = 1
func increment(_ num: inout Int) {
    num += step
}
increment(&step)

上面第二部分代碼就是同時對step變量執(zhí)行讀寫操作, 運(yùn)行時會報出如下錯誤

Simultaneous accesses to 0x100002028, but modification requires exclusive access.

再看下面對于結(jié)構(gòu)體和元組的使用, 這里先定義一個全局函數(shù)和一個結(jié)構(gòu)體

// 改變兩個傳入?yún)?shù)的值, 讀取并修改傳入?yún)?shù)的值
func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}

// 定義Player結(jié)構(gòu)體
struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}

再看下面的使用示例, 兩者都會有一個內(nèi)存訪問沖突的錯誤

// 這里讀寫的是同一個maria
var maria = Player(name: "Maria", health: 50, energy: 10)
balance(&maria.health, &maria.energy)

// 這里讀寫的是同一個tuple
var tuple = (health: 10, energy: 20)
balance(&tuple.health, &tuple.energy)

但是有時候的確會有上面這種訪問同一塊內(nèi)存的需求, 如果下面的條件滿足, 就說明重疊訪問結(jié)構(gòu)體的屬性是安全的

• 訪問的是實(shí)例存儲屬性, 不是計算屬性或者類屬性
• 結(jié)構(gòu)體是局部變量而非全局變量
• 結(jié)構(gòu)體要么沒有被閉包捕獲要么只被非逃逸閉包捕獲

// 這里可以在局部作用域內(nèi)定義成局部變量, 就不會有問題了
func test() {
    var maria = Player(name: "Maria", health: 50, energy: 10)
    var tuple = (health: 10, energy: 20)
    balance(&tuple.health, &tuple.energy)
    balance(&maria.health, &maria.energy)
}

指針

class Person {}
var person = Person()

• 在Swift中class聲明的類(Person)是引用類型, 初始化的person對象其本質(zhì)上就是一個指針變量
• 而person里面存儲的就是這個指針變量的地址值, 也就可以根據(jù)這個地址值去訪問被分配的內(nèi)存空間
• 指針在某種意義上被定性為不安全的, 舉個例子:
  • 當(dāng)前指針變量的地址值對應(yīng)的空間只有32個字節(jié), 但有可能訪問的是超過32個字節(jié)的空間, 這樣就可能會出問題的

指針分類

在Swift中也有專門的指針類型，這些都被定性為Unsafe（不安全的），常見的有以下4種類型

• UnsafePointer<Pointee>, 類似于C語言中的const Pointee *, 只能訪問內(nèi)存不能修改內(nèi)存, 這里的Pointee是指泛型
• UnsafeMutablePointer<Pointee>類似于C語言中的Pointee *, 可以訪問和修改內(nèi)存, 這里的Pointee是指泛型
• UnsafeRawPointer類似于const void *, 不支持泛型
• UnsafeMutableRawPointer類似于void, 不支持泛型

下面看一下具體的使用示例

var age = 10
func sum1(_ ptr: UnsafeMutablePointer<Int>) {
    // 通過訪問pointee屬性, 獲取ptr指針的內(nèi)存地址所存儲的值
    // UnsafeMutablePointer的pointee屬性是可讀可寫的
    ptr.pointee += 10
}
func sum2(_ ptr: UnsafePointer<Int>) {
    // UnsafePointer的pointee屬性是只讀的
    // ptr.pointee += 10
    print(ptr.pointee)
}
func sum3(_ num: inout Int) {
    // 
    num += 10
}

// 和inout輸入輸出參數(shù)一樣接受變量的地址值
sum1(&age)
sum2(&age)
sum3(&age)
print(age)


func sum4(_ ptr: UnsafeMutableRawPointer) {
    // 可讀可寫, 取值
    print("age = ", ptr.load(as: Int.self))
    // 可讀可寫, 賦值
    ptr.storeBytes(of: 50, as: Int.self)
}
func sum5(_ ptr: UnsafeRawPointer) {
    // 只讀, 取值
    print("age = ", ptr.load(as: Int.self))
}

sum4(&age)
sum5(&age)

獲得變量的指針

Swift中有可以直接獲取變量的指針的方法

// 獲取可變的變量指針, value參數(shù)接受變量地址
@inlinable public func withUnsafeMutablePointer<T, Result>(to value: inout T, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
// 獲取不可變的變量指針, value參數(shù)接受變量
@inlinable public func withUnsafePointer<T, Result>(to value: T, _ body: (UnsafePointer<T>) throws -> Result) rethrows -> Result
// 獲取不可變的變量指針, value參數(shù)接受變量地址
@inlinable public func withUnsafePointer<T, Result>(to value: inout T, _ body: (UnsafePointer<T>) throws -> Result) rethrows -> Result

上述方法中返回值默認(rèn)是變量的指針地址, 也可以是其他的數(shù)據(jù)類型, 主要取決于body閉包的返回值, 返回值類型由閉包中的Result泛型決定

var age = 10
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 }   // UnsafeMutablePointer<Int>
var ptr2 = withUnsafePointer(to: &age) { $0 }          // UnsafePointer<Int>
ptr1.pointee = 22
print(ptr2.pointee) // 22
print(ptr2)         // 0x0000000100008310

var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) }   // UnsafeMutableRawPointer
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) }                 // UnsafeRawPointer
// as參數(shù)是需要存儲什么類型的數(shù)據(jù)
ptr3.storeBytes(of: 33, as: Int.self)
print(ptr4.load(as: Int.self)) // 33
print(ptr4)         // 0x0000000100008310

創(chuàng)建指針

• 之前獲取到的指針都是根據(jù)已經(jīng)存在的內(nèi)存獲取的
• 這里就看看重新分配一塊內(nèi)存指向堆空間

malloc

Swift提供了malloc直接分配內(nèi)存創(chuàng)建指針的方式

// 根據(jù)需要分配的內(nèi)存大小創(chuàng)建一個指針
public func malloc(_ __size: Int) -> UnsafeMutableRawPointer!
// 釋放內(nèi)存
public func free(_: UnsafeMutableRawPointer!)


// 下面這兩個函數(shù), 是賦值和取值的函數(shù), 之前簡單介紹過
// 參數(shù)一: 需要存儲的值
// 參數(shù)二: 偏移量, 從第幾個字節(jié)開始存儲, 默認(rèn)從第一個
// 參數(shù)三: 需要存儲的值的類型
@inlinable public func storeBytes<T>(of value: T, toByteOffset offset: Int = 0, as: T.Type)

// 參數(shù)一: 偏移量, 從第幾個字節(jié)開始存儲, 默認(rèn)從第一個
// 參數(shù)二: 需要存儲的值的類型
@inlinable public func load<T>(fromByteOffset offset: Int = 0, as type: T.Type) -> T

代碼示例如下

// 創(chuàng)建指針
var ptr = malloc(16)
// 存儲值
ptr?.storeBytes(of: 10, as: Int.self)
// 這里toByteOffset參數(shù)如果傳0, 就會覆蓋前8個字節(jié)的數(shù)據(jù)
ptr?.storeBytes(of: 12, toByteOffset: 8, as: Int.self)
// 取值
print(ptr?.load(as: Int.self) ?? 0)
print(ptr?.load(fromByteOffset: 8, as: Int.self) ?? 0)
// 銷毀, 釋放內(nèi)存
free(ptr)

allocate

使用allocate方式創(chuàng)建指針, 代碼示例如下

// byteCount: 需要申請的字節(jié)數(shù), alignment: 對其字節(jié)數(shù)
var ptr2 = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
// 存儲
ptr2.storeBytes(of: 9, as: Int.self)

// 根據(jù)字節(jié)偏移存儲
// 這里的ptr3是ptr2偏移8個字節(jié)的新的指針地址
var ptr3 = ptr2.advanced(by: 8)  // UnsafeMutableRawPointer
ptr3.storeBytes(of: 12, as: Int.self)

// 上面這種方式等價于
ptr2.storeBytes(of: 12, toByteOffset: 8, as: Int.self)

// 取值同樣
print(ptr2.load(as: Int.self))
// 下面這兩種取值方式也是一樣的
print(ptr2.advanced(by: 8).load(as: Int.self))
print(ptr2.load(fromByteOffset: 8, as: Int.self))

// 釋放內(nèi)存
ptr2.deallocate()

這里需要注意的是只有UnsafeMutableRawPointer才有allocate分配方法, UnsafeRawPointer是沒有這個方法的, 下面說到的UnsafeMutablePointer<T>類型也是, UnsafePointer<T>沒有allocate分配方法

// capacity: 容量, 即可以存儲3個Int類型的數(shù)據(jù), 也就是24個字節(jié)
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3)
// 初始化內(nèi)存, 用10初始化錢8個字節(jié)
ptr.initialize(to: 10)
// 用10初始化前兩個容量的內(nèi)存, 即16個字節(jié)
ptr.initialize(repeating: 10, count: 2)
// 使用successor獲取下一個存儲位, 也就是下一個Int的位置
var ptr1 = ptr.successor()  //  UnsafeMutablePointer<Int>
ptr1.initialize(to: 20)
// 存儲第三個Int值
ptr.successor().successor().initialize(to: 30)

// 取值的兩種方式
print(ptr.pointee)        // 第一個值
print((ptr + 1).pointee)  // 第二個值
print((ptr + 2).pointee)  // 第三個值

// 下面這種方式和上面等價
print(ptr[0])
print(ptr[1])
print(ptr[2])

// 前面如果使用了initialize, 則必須調(diào)用反初始化
// 而且count要和上面allocate(capacity: 3)的capacity一致, 否則會造成內(nèi)存泄露的問題
ptr.deinitialize(count: 3)
ptr.deallocate()

指針之間的轉(zhuǎn)換

前面提到過Swift中的指針類型有四種

• UnsafePointer<Pointee>類似于const Pointee *
• UnsafeMutablePointer<Pointee>類似于Pointee *
• UnsafeRawPointer類似于const void *
• UnsafeMutableRawPointer類似于void *
• 那么上面的類型, 能否通過其中的一種創(chuàng)建另外一種指針呢, 下面我們來看一下

init

UnsafeMutableRawPointer中有一個初始化方法可以根據(jù)UnsafeMutablePointer創(chuàng)建自身

public init<T>(_ other: UnsafeMutablePointer<T>)

var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3)
var ptr1 = UnsafeMutableRawPointer(ptr)

assumingMemoryBound

反過來, UnsafeMutableRawPointer也提供了一個方法用于創(chuàng)建UnsafePointer

public func assumingMemoryBound<T>(to: T.Type) -> UnsafePointer<T>

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
var ptr1 = ptr.assumingMemoryBound(to: Int.self)
// 初始化前8個字節(jié)
ptr1.pointee = 11
// 初始化后8個字節(jié)
// 特別注意, 這里的(ptr + 8)是指ptr向后偏移8個字節(jié), 要和之前的區(qū)分開
(ptr + 8).assumingMemoryBound(to: Int.self).pointee = 12

ptr.deallocate()

unsafeBitCast

unsafeBitCast是忽略數(shù)據(jù)類型的強(qiáng)制轉(zhuǎn)換，不會因?yàn)閿?shù)據(jù)類型的變化而改變原來的內(nèi)存數(shù)

// 把第一個參數(shù)類型轉(zhuǎn)成第二個參數(shù)類型
@inlinable public func unsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U


var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
unsafeBitCast(ptr, to: UnsafeMutablePointer<Int>.self).pointee = 13
// 注意, 這里的(ptr + 8)是指ptr向后偏移8個字節(jié), 要和之前的區(qū)分開
unsafeBitCast(ptr + 8, to: UnsafeMutablePointer<Double>.self).pointee = 14.23

ptr.deallocate()