Swift开发基础07-内存布局

标签：07 计数 ARC 引用 print Swift 内存

了解Swift的内存布局和底层原理对于编写高性能和内存高效的应用非常重要。接下来，我将更详细地介绍Swift的内存管理机制和一些底层实现细节，包括内存布局、ARC（自动引用计数）、引用类型和值类型的区别，及其在底层的实现。

内存布局（Memory Layout）

栈（Stack）

栈内存用于存储函数调用帧（Call Stack）、局部变量和函数参数。栈的特点是LIFO（Last In, First Out），即最后进入的最先出去。栈内存分配和释放速度非常快，但栈的空间是有限的。

堆（Heap）

堆内存用于存储动态分配的内存，比如对象、闭包等。堆的内存管理相对复杂，需要显式管理分配和释放。Swift通过ARC来自动管理堆内存。

值类型与引用类型的内存布局

值类型（Value Type）:
- 存储在栈上或嵌入到引用类型中的对象内部。
- 包括基本类型（整数、浮点数、布尔值）、结构体、枚举等。
- 每次赋值会拷贝一份独立的数据。
引用类型（Reference Type）:
- 存储在堆上，并通过指针引用管理。
- 包括类（Class）、闭包（Closure）等。
- 赋值操作只会复制指针，而不会复制对象本身。

自动引用计数（ARC）

ARC在运行时管理引用类型实例的内存生命周期。每个引用类型实例有一个引用计数（Reference Count），当引用计数为零时，ARC会自动释放该实例的内存。

ARC的底层机制

引用计数增加（retain）：
- 每当有新的引用指向一个对象，其引用计数加一。
- 底层实现为调用objc_retain。
引用计数减少（release）：
- 每当一个引用不再指向该对象，其引用计数减一。
- 底层实现为调用objc_release。
内存释放：
- 当引用计数为零时，对象的deinit方法被调用，然后释放对象占用的内存。

ARC示例

class ExampleClass {
    let name: String

    init(name: String) {
        self.name = name
        print("\(name) is initialized")
    }
    
    deinit {
        print("\(name) is being deallocated")
    }
}

var object1: ExampleClass? = ExampleClass(name: "Object1")  // 引用计数+1
var object2 = object1  // 引用计数+1，此时引用计数为2
object1 = nil          // 引用计数-1，此时引用计数为1
object2 = nil          // 引用计数-1，此时引用计数为0，对象被释放

上下文捕获（Context Capture）

捕获机制

闭包可以捕获并存储其上下文中的变量和常量，即使这些变量和常量在闭包创建时已经作用域结束。Swift通过将被捕获的变量存储在堆上来实现这种捕获。

func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    let incrementer: () -> Int = {
        total += incrementAmount
        return total
    }
    return incrementer
}

let incrementByTwo = makeIncrementer(incrementAmount: 2)

print(incrementByTwo()) // 输出: 2
print(incrementByTwo()) // 输出: 4

在这个例子中，total和incrementAmount被捕获到堆中，并在闭包中引用。

Swift底层对象模型

Swift类的内存布局

Swift类的内存布局包含一个头部和实例数据部分。头部通常包含：

引用计数：用于ARC。
类元数据指针：指向类型元数据（Class Metadata）。

方法派发（Method Dispatch）

Swift支持多种方法派发方式：

Direct Dispatch（直接派发）：主要用于值类型或没有多态性的类。
- 编译时决定，性能最高。
VTable Dispatch（虚表派发）：用于引用类型的多态方法调用。
- 通过虚表（VTable）找到方法的具体实现。
Message Dispatch（消息派发）：主要用于兼容Objective-C的类。
- 通过运行时的消息机制进行方法调用。

class BaseClass {
    func printMessage() {
        print("BaseClass")
    }
}

class SubClass: BaseClass {
    override func printMessage() {
        print("SubClass")
    }
}

let instance: BaseClass = SubClass()
instance.printMessage() // 运行时通过VTable找到SubClass的方法，输出: "SubClass"

内存安全（Memory Safety）

变量初始化：
- Swift强制在使用变量之前进行初始化，避免未初始化变量的使用。
数组越界检查：
- Swift在访问数组元素时，会进行边界检查，防止越界访问。
原子性：
- Swift对内存的读写操作是原子的，可以避免数据竞争。

组合的安全示例

综合上述内容，以下是一个更复杂的示例，展示了闭包捕获、ARC、VTable派发以及内存安全性：

class Counter {
    var count = 0
    
    func increment() -> Int {
        count += 1
        return count
    }
    
    deinit {
        print("Counter is being deallocated")
    }
}

func makeCounter() -> () -> Int {
    let counter = Counter()
    
    let increment: () -> Int = { [weak counter] in
        guard let counter = counter else { return 0 }
        return counter.increment()
    }
    
    return increment
}

let incrementer = makeCounter()
print(incrementer()) // 输出: 1
print(incrementer()) // 输出: 2

上面的示例展示了如何在Swift中效率和安全地处理内存。通过理解这些底层细节，能更好地编写性能高效、内存安全的Swift代码。

标签：07,计数,ARC,引用,print,Swift,内存
From： https://www.cnblogs.com/chglog/p/18047564