swift - 内存管理

在 Swift 中，内存管理主要通过 ARC（Automatic Reference Counting，自动引用计数）机制来实现。ARC 用于管理对象类型（类的实例）的内存分配和释放。对于值类型（如枚举、结构体、基础数据类型），他们通常存储在栈上，由编译器负责管理内存。

以下是 Swift 中内存管理的主要概念：

自动引用计数（ARC）：ARC 是一种用于跟踪引用类型（类的实例）内存占用情况的机制。它在实例被创建时分配内存、在实例不再被需要时释放内存。当一个实例的引用计数变为 0 时，ARC 将释放该实例占用的内存。

class MyClass {
    init() {
        print("MyClass 初始化")
    }
    deinit {
        print("MyClass 析构")
    }
}

// 类的实例被创建，ARC 分配内存。
var myInstance: MyClass? = MyClass() // 输出：MyClass 初始化

// myInstance 设置为 nil，类的实例不再被需要，ARC 会释放占用的内存。
myInstance = nil // 输出：MyClass 析构

循环引用（retain cycle）：循环引用是指两个或多个实例存在相互引用的问题，导致它们无法被正确释放。可以通过使用弱引用或无主引用解决循环引用问题。
强引用和弱引用：强引用是指一个实例的引用计数会因为引用而增加，而弱引用则不会增加引用计数。强引用可以确保实例在其被引用的生命周期内保持有效。使用弱引用可以避免循环引用（retain cycle）问题。

class Person {
    let name: String
    var apartment: Apartment?

    init(name: String) { self.name = name }
    deinit { print("\(self.name) 析构") }
}

// 循环引用（retain cycle）示例
class Apartment {
    let unit: String
    var tenant: Person?
    
    init(unit: String) { self.unit = unit }
    deinit { print("Apartment \(unit) 析构") }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john

该示例中，Person 实例和 Apartment 实例互相引用，如果不处理循环引用，会导致内存泄漏。接下来，使用弱引用（weak）来解决这个问题：

class Apartment {
    let unit: String
    weak var tenant: Person?
    
    init(unit: String) { self.unit = unit }
    
    deinit { print("Apartment \(unit) 析构") }
}

弱引用（weak）和无主引用：两者都是引用实例但是不会增加引用计数，常用于防止循环引用问题。区别在于当使用引用的实例被释放时，弱引用自动变为 nil；无主引用需确保在访问时其引用的实例是有效的，若试图访问已经被释放的无主引用，将导致运行时错误。
值类型内存管理：值类型（如结构体、枚举）在赋值或传递参数时会进行复制。Swift 采用了 Copy-On-Write（COW，写时复制）优化策略，只有当值类型需要被修改时，Swift 才会进行实际的复制操作。值类型通常存储在栈上，其内存管理由编译器处理。当值类型的变量超出其作用域时，内存会自动释放。

以下是一个值类型（结构体）的简单示例：

struct Dog {
    var name: String
}

var dog1 = Dog(name: "Buddy")
var dog2 = dog1 // 并未执行实际的复制操作

dog2.name = "Max" // 此时，由于 dog2 需要改变值，实际的复制操作才会执行

内存泄漏与僵尸对象：内存泄漏是指由于错误的代码实现导致内存没有被正确释放的现象。僵尸对象指的是已被释放但仍然被保留指针指向的对象，访问僵尸对象可能导致应用程序崩溃。

我们已经举了循环引用导致内存泄漏的例子，以下是一个关于僵尸对象的简单示例：

首先，我们创建一个简单的类 Car：

class Car {
    var name: String

    init(name: String) {
        self.name = name
    }

    deinit {
        print("Car: \(name) 析构")
    }
}

现在，我们将创建一个 Car 类的实例，并在释放它之后尝试访问其属性。这会创建一个僵尸对象。

var car: Car? = Car(name: "Tesla")
var pointerToCar: Unmanaged<Car>? = Unmanaged.passUnretained(car!)

// 此时 car 指向的实例已被释放
car = nil

if let zombieCar = pointerToCar?.takeUnretainedValue() {
    // 此时尝试访问已被释放的对象。这很可能导致应用程序崩溃。
    print("Car name: \(zombieCar.name)")
}

注意：此示例使用 Unmanaged 类型来创建对已释放对象的指针。在实际开发中，我们应该始终避免创建僵尸对象，因为这可能导致应用程序崩溃。要避免僵尸对象，请确保在访问对象之前始终有一个有效的强引用。同时，在不再需要引用时，将引用设为 nil 以允许 ARC 释放内存。

Swift 编程语言的内存管理旨在通过 ARC、弱引用/无主引用、Copy-On-Write 等技术，兼顾性能和显式语义，减轻开发者在内存管理上的负担。然而，避免循环引用和内存泄漏仍然需要开发者在编写代码时保持关注。

swift - 内存管理

推荐阅读更多精彩内容