Swift-内存管理

【返回目录】

一、内存管理

Swift与Objective-C一样，也是采取基于引用计数的ARC内存管理方案（针对堆空间）。在Swift中的ARC中有以下三种引用：

• 强引用（Strong Reference）：默认是强引用
• 弱引用（Weak Reference）：通过weak定义
  • 必须是可选类型的var，因为实例销毁后ARC会自动将弱引用设置为nil；
  • ARC自动给弱引用设置为nil，不会触发属性观察器
• 无主引用（Unowned Reference）：通过unowned定义
  • 不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的unsafe_unretained）
  • 试图在实例销毁后访问无主引用会产生运行时错误（野指针）
  • 运行时错误:Fatal error: Attempted to read an unowned reference but object 0x0 was already deallocated
    
    
    
    

weak、unowned的使用限制

• weak、unowned只能用在实例上面
  • 在结构体、枚举里是不支持weak的
  • 只能用在类里，因为只有类才存在堆空间
  • 可以定义在已遵守AnyObject协议的协议

protocol Livable: AnyObject {}//将来只能被类遵守
class Person {}

weak var person: Person?
weak var anyobject: AnyObject?
weak var livable: Livable?

unowned var person: Person?
unowned var any: AnyObject?
unowned var livable: Livable?

协议去掉AnyObject编译器报错：

• 'weak' must not be applied to non-class-bound 'Livable'; consider adding a protocol conformance that has a class bound

AutoreleasePool

• 在Swift中有@UIApplicationMain，不再需要main文件和main函数，所以原来的整个程序的自动释放池就不存在了。即使使用main.swift来作为程序的入口，也不需要自己再添加自动释放池了。

• 在Swift中也能使用autoreleasepool,只是语法上略有不同。相比与原来在Objective-C中的关键字，它现在变成了一个接受闭包的方法：

public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result

• 使用

autoreleasepool {
    let p = Person()
    p.run()
}

二、循环引用（Reference Cycle）

• weak、unowned都能解决循环引用的问题，unowned要比weak少一些性能消耗

  • 在生命周期中可能会变为nil的使用weak
  • 初始化赋值后再也不会变为nil的使用unowned

• 下面代码回引起循环引用，相互持有。

class Person {
    var student: Apartmer?
    deinit {
        print("Person deinit")
    }
}


class Apartmer {
    var person: Person?
    deinit {
        print("Student deinit")
    }
}

var p: Person?  = Person()
var s: Apartmer? = Apartmer()

p?.student = s
s?.person = p

s = nil
p = nil

使用weak、unowned解决

weak var person: Person?
unowned var person: Person?

闭包

• Swift闭包：

  • 一个函数和它所捕获的变量\常量环境组合起来，称为闭包，可以把闭包想象成是一个类的实例对象。
  • 一般指定义在函数内部的函数。
  • 一般它捕获的是外层函数的局部变量\常量。
  • 参考OC的block定义：block是封装了函数调用以及函数调用环境的OC对象。

• 闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了retain操作）

• 下面代码会产生循环引用，导致Person对象无法释放（看不到Person的dealloc被调用）

class Person {
    var fn:(() -> ())?
    func run() { print("run") }
    deinit {
        print("Person deinit")
    }
}
func test(){
    let p = Person()
    p.fn = {
        p.run()
    }
}

解决循环引用问题

在闭包表达式的捕获列表声明weak或unowned引用，解决循环引用问题。

• 使用weak解决

p.fn = {
    //[捕获列表](参数列表) in 函数体
    [weak p] in
    p?.run()
}

• 使用unowned解决

p.fn = {
    //[捕获列表](参数列表) in 函数体
    [unowned p] in
    p?.run()
}

• 捕获列表
  • 可以定义新的名称
  • 可以设置其他变量

p.fn = {
    [unowned p = up, weak wp = p, a = 10+ 20] in
    p?.run()
}

lazy

• 如果想在定义闭包属性的同时引用self，这个闭包必须是lazy的（因为实例初始化完毕之后才能引用self）

• 如果lazy属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的是生命周期就结束了）

• 下边的闭包fn内部如果用到了实例成员（属性、方法），编译器会强制要求明确写self

class Person {
    lazy var fn: (() -> ()) = {
        [weak self] in
        self?.run() //编译器强制要求写出self
    }
    func run() { print("run") }
    deinit { print("deinit") }
}

三、@escaping

• 非逃逸闭包：
  • 一般都是当做参数传递给函数
  • 闭包调用发生在函数结束前，闭包调用在函数作用域内

typealias Fn = () -> ()
// fn是非逃逸闭包
func test1(_ fn: Fn) {
    fn()
}

• 逃逸闭包：闭包调用有可能在函数结束后，闭包调用逃离了函数的作用域，需要通过@escaping声明

var gFn: Fn?
// fn是逃逸闭包
func test2(_ fn: @escaping Fn) {
    gFn = fn //fn没有调用，而是传递给了gFn，有可能在函数结束后调用
}

// fn是逃逸闭包
func test3(_ fn: @escaping Fn) {
    DispatchQueue.global().async {
        fn() //因为是全局并发队列，所以fn的调⽤有可能在函数作⽤域之外
    }
}

• 逃逸闭包不允许捕获输入输出参数inout

内存访问冲突（Conflicting Access to Memory）

• 内存访问冲突会在两个访问满足下列条件时发生：
  • 至少一个是写入操作
  • 它们访问的是同一块内存
  • 它们的访问时间重叠（比如在同一个函数内）

• 如果下面的条件可以满足，就说明重叠访问结构体的属性是安全的
  • 你只访问实例存储属性，不是计算属性或者类属性
  • 结构体是局部变量而非全局变量
  • 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获（要么就没闭包，如果有闭包的话只能是⾮逃逸闭包）

指针

• Swift中也有专门的指针类型，这些都被定性为“Unsafe”（不安全的），常见的有以下4种类型：
  • UnsafePointer 类似于 const Pointee *
  • UnsafeMutablePointer 类似于 Pointee *
  • UnsafeRawPointer 类似于 const void *
  • UnsafeMutableRawPointer 类似于 void *

【参考文章】

【上一篇】：访问控制
【下一篇】：字面量