Swift中的内存管理

 

内存管理

1、跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案（针对堆空间）

2、Swift的ARC中有3种引用

• 强引用（strong reference）：默认情况下，引用都是强引用
• 弱引用（weak reference）：通过weak定义弱引用

必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil

ARC自动给弱引用设置为nil时，不会触发属性观察器

• 无主引用（unowned reference）：通过unowned定义无主引用

不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的unsafe_unretained）；

试图在实例销毁后访问无主引用，会产生运行时错误（野指针）。

weak、unowned的使用限制

1、weak、unowned只能用在类实例上面

Autoreleasepool

autoreleasepool {
    
}

循环引用（Reference Cycle）

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

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

闭包的循环引用

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

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

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

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

test()

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

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

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

class Person {
    lazy var fn: (() -> ()) = {
        [weak p = self] in
        p?.run()
    }
    
    func run() {
        print("run")
    }
    
    deinit {
        print("deinit")
    }
}

5、左边的闭包fn内部如果用到了实例成员（属性、方法）

• 编译器会强制要求明确写出self

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

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

func test() {
    var p = Person()
    print(p.getAge)
}

test()

@escaping

1、非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数

2、非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内

func test(_ fn: () -> ()) {
    fn()
}

test {
    print(1)
}

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

import Dispatch

typealias Fn = () -> ()

func test(_ fn: @escaping Fn) {
    DispatchQueue.global().async {
        fn()
    }
}

import Dispatch

typealias Fn = () -> ()

class Person {
    var fn: Fn
    
    init(fn: @escaping Fn) {
        self.fn = fn
    }
    
    func run() {
        DispatchQueue.global().async {
//            self.fn()
            
            [weak p = self] in
            p?.fn()
        }
    }
}