詳解Swift的內(nèi)存管理

更新時間：2021年04月27日 11:00:55 作者：淺笑·

這篇文章主要介紹了Swift的內(nèi)存管理，對內(nèi)存管理感興趣的同學(xué)，可以參考下

內(nèi)存管理

和OC一樣, 在Swift中也是采用基于引用計數(shù)的ARC內(nèi)存管理方案(針對堆空間的內(nèi)存管理)

在Swift的ARC中有三種引用

強引用(strong reference)：默認(rèn)情況下，代碼中涉及到的引用都是強引用
弱引用(weak reference)：通過weak定義弱引用
無主引用(unowned reference)：通過unowned定義無主引用

weak

弱引用(weak reference)：通過weak定義弱引用必須是可選類型的var，因為實例銷毀后，ARC會自動將弱引用設(shè)置為nilARC自動給弱引用設(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)生強引用，實例銷毀后仍然存儲著實例的內(nèi)存地址(類似于OC中的unsafe_unretained）

試圖在實例銷毀后訪問無主引用，會產(chǎn)生運行時錯誤（如下野指針)

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

需要注意的是

weak、unowned只能用在類實例上面, 如下所示

// 該協(xié)議表示只能被類遵守, AnyObject代表所有的類實例
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)閚il的使用weak
初始化賦值后再也不會變?yōu)閚il的使用unowne
說道循環(huán)引用就自然想到了閉包

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

閉包表達式默認(rèn)會對用到的外層對象產(chǎ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對象強引用著fn閉包,fn閉包也強引用著p對象, 自然就造成了循環(huán)引用問題

最后沒有任何輸出結(jié)果, 我們看一下上述代碼的匯編執(zhí)行過程

從上面匯編代碼可以看出, 整個過程經(jīng)歷了

一次init引用計數(shù)為: 1

一次retain引用計數(shù)會加(1), 結(jié)果為: 2

一次release引用計數(shù)會減(1), 結(jié)果為: 1

那么最后的引用計數(shù)就是1, 所以p對象肯定沒有被釋放

下面是使用解決循環(huán)引用的情況

在閉包表達式的捕獲列表里, 聲明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)引用的問題, 運行后就發(fā)現(xiàn)Person對象調(diào)用了deinit這里我們再看一下匯編代碼如下, 從下面匯編代碼中可以很明顯看到, 引用計數(shù)最后為0, 對象被釋放

下面這段代碼其實是等價的

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()
    }
}

特別注意點

這里要區(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的

因為實例在初始化完畢之后才能引用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)部用到了實例成員(屬性和方法), 則編譯器會強制要求明確寫出selflazy既保證只有在使用的時候才會被初始化一次但是上述代碼同樣存在循環(huán)引用的問題,Person對象強引用著fn閉包,fn閉包也強引用著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í)行讀寫操作, 運行時會報出如下錯誤

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)體的屬性是安全的

訪問的是實例存儲屬性, 不是計算屬性或者類屬性
結(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語言中的constPointee *, 只能訪問內(nèi)存不能修改內(nèi)存, 這里的Pointee是指泛型
UnsafeMutablePointer<Pointee>類似于C語言中的Pointee *, 可以訪問和修改內(nèi)存, 這里的Pointee是指泛型
UnsafeRawPointer類似于constvoid *, 不支持泛型
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ù)類型的強制轉(zhuǎ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()

以上就是詳解Swift的內(nèi)存管理的詳細(xì)內(nèi)容，更多關(guān)于Swift內(nèi)存管理的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: