Swift学习：内存管理

内存管理

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

class Person {
    deinit {
        print("Person.deinit")
    }
}

print(1)
var p: Person? = Person()
print(2)
p = nil
print(3)
//输出结果为：
//1
//2
//Person.deinit
//3

由上图可以看出，p置为nil时，对象销毁，走deinit方法 

• Swift的ARC中有3种引用：
• 强引用(strong reference):默认情况下，引用都是强引用
• 弱引用(weak reference):通过weak定义弱引用

1. 必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil 
2. ARC自动给弱引用设置nil时，不会触发属性观察器

class Dog { }
class Person {
    weak var dog: Dog? {
        willSet { }
        didSet { }
    }
    deinit {
        print("Person.deinit")
    }
}

• 无主引用(unowned reference):通过unowned定义无主引用

1. 不会产生强引用，实例销毁后仍然存储着实例的内存地址(类似于OC中的unsafe_unretained)
2. 试图在实例销毁后访问无主引用，会产生运行时错误(野指针)
3.  Fatal error: Attempted to read an unowned reference but object 0x0 was already deallocated

class Dog { }
class Person {
    unowned var dog: Dog {
        willSet { }
        didSet { }
    }
    deinit {
        print("Person.deinit")
    }
    init() {
        self.dog = Dog()
    }
}

---

weak、unowned的使用限制

• weak，unowned只能用在类实例上面

 其中的Livable协议继承自AnyObject，所以只有类能遵守此协议，所以只有类实例能用

---

autoReleasepool

---

循环引用（Reference Cycle）

• weak、unowned 都能解决循环引用的问题，unowned 要比weak 少一些性能消耗
• 在生命周期中可能会变为 nil 的使用 weak
• 初始化赋值后再也不会变为 nil 的使用 unowned

---

闭包的循环引用

• 闭包表达式默认会对用到的外层对象产生额外的强引用(对外层对象进行了retain操作) 
• 下面代码会产生循环引用，导致Person对象无法释放(看不到Person的deinit被调用)

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

func test() {
    let p = Person()
    //p对闭包fn有一个强引用，闭包对p也有一个强引用
    p.fn = {
        p.run()
    }
}

test() //这里不会输出deinit，因为闭包产生了循环引用

通过反汇编我们可以窥探其原理，也就是引用计数的变化：

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

weak的方式：

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

func test() {
    let p = Person()
    //p对闭包fn有一个强引用，闭包对p也有一个强引用
    p.fn = {
        [weak p] in
        p?.run()
    }
}

test() //deinit 对象销毁

unowned的方式：

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

func test() {
    let p = Person()
    //p对闭包fn有一个强引用，闭包对p也有一个强引用
    p.fn = {
        [unowned p] in
        p.run()
    }
}

test() //deinit 对象销毁

甚至可以在捕获列表中给P对象重命名，或设置新的参数a

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

class Person {
    //lazy保证了只用调用fn函数时才会初始化里面的self
    lazy var fn: (() -> ()) = {
        //消除循环引用
      [weak self] in
      self?.run()
      //unowned也可以消除循环引用
      //[unowned self] in
      //self.run()
    }
    func run()  {
        print("run")
    }
    deinit {
        print("deinit")
    }
}

func test() {
    var p = Person()
    p.run()
}

test()
//输出结果
//run
//deinit

• 如果上边的闭包fn内部如果用到了实例成员(属性、方法)，编译器会强制要求明确写出self
• 如果lazy属性是闭包调用的结果，那么不用考虑循环引用的问题(因为闭包调用后，闭包的生命周期就结束了)

---

@escaping

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

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

闭包fn只是赋给了全局变量gFn，gFn可能在函数结束后调用，所以闭包fn也可能在函数结束后调用，所以要加@escaping

因为下图中的fn()的实现调用是在全局队列异步函数中，所以可能在test3函数结束后调用fn，这时如果fn函数里使用了test3函数里的变量或方法，是会报错的，因为已经销毁了，所以要加@escaping

Dispatch结合逃逸闭包实例如下：

typealias Fn = () -> ()
class Person {
    var fn: Fn
    //fn是逃逸闭包
    init(fn: @escaping Fn) {
        self.fn = fn
    }
    func run( ) {
        //DispatchQueue.global().async也是一个逃逸闭包
        //它用到了实例成员（属性、方法），编译器会强制要求明确写出self，这样会对Person的对象的生命周期产生影响，保证在DispatchQueue.global().async中调用后再销毁
        DispatchQueue.global().async {
            self.fn()
            //如果想要保证如果self这个Person实例销毁了就不调用fn函数，防止崩溃，就要用weak声明self，并把实例对象p写成可选型，代码如下：
//            [weak p = self] in
//            p?.fn()
        }
    }
}

• 逃逸闭包不可以捕获inout参数

示例1: 当调用test函数，传入一个value的地址，由于other2是逃逸闭包，有可能在test函数执行完，value已经销毁的情况下执行，这时候传给other2的value的地址已经销毁，所以会报错

示例2:  这里的返回值是plus，是一个闭包函数，并不知道什么时候调用，但是用到了test方法里的参数，有可能造成和示例1里一样逃逸闭包的问题，所以报错