闭包的循环引用

• 闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了retain操作），保证执行代码时变量还在。

循环应用的案例

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

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

func test(){
    let p = Person()
   //将闭包赋值给一个实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，这边将创建一个闭包和该实例之间的循环强引用。
    p.fn = { p.run() }
}
test()

ObjC中如何解决循环引用

• __weak typeof(self) weakSelf = self;
  • 对象释放后会自动将变量赋值为nil
• __unsafe_unretained typeof(self) weakSelf = self;
  • 对象释放后不会自动将变量赋值为nil，指向一块废弃的存储空间

Swift中如何解决循环引用

• weak var weakSelf = self

  • weak 相当于ObjC中 __weak,和OC一样，对象释放后会自动将变量赋值为nil，被weak修饰的变量是可选类型

• unowned var weakSelf = self

  • unowned 相当于ObjC中__unsafe_unretained,和ObjC中一样，对象释放后不会自动将变量赋值为nil，被unowned修饰的变量不是可选类型

• 什么时候用weak

  • 当被保存的对象有可能提前释放时就用weak
  • 在生命周期内可能会变为nil的使用weak

• 什么时候用unowned

  • 当被保存的对象在使用时不会被提前释放时就用unowned
  • 初始化赋值后再也不会变为nil的使用unowned

注意
weak和unowned只能修饰对象类型, 因为只有对象类型才有引用计数

捕获列表

• 可以在调用闭包时在形参列表前面通过[ ]指定捕获列表, 告诉系统如何处理指定的这些值

解决循环引用

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

func test(){
    let p = Person()
    p.fn = {
        [weak weakp = p, unowned unownedp = p, a = 10 + 20 ] in
        weakp?.run()
    }
}

使用闭包时的注意点

• 如果想在定义闭包属性的同时引用self，这个闭包必须是lazy的（应为在实例初始化完毕之后才能引用self）
• 下面的闭包fn内部如果用到了实例成员（属性、方法），编译器会强制要求明确写出self

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

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

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

@escaping

• 非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
• 非逃逸闭包:闭包调用发生在函数结束前，闭包调用在函数作用域内
• 逃逸闭包:闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明

import Dispatch

typealias Fn = () -> ()

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

// fn是逃逸闭包
var gFn: Fn?
func test2(_ fn: @escaping Fn) { gFn = fn }

 // fn是逃逸闭包
func test3(_ fn: @escaping Fn) {
    DispatchQueue.global().async { fn()}
}

class Person {
    var fn: Fn
    // fn是逃逸闭包
    init(fn: @escaping Fn) {
        self.fn = fn
    }
    func run() {
        // DispatchQueue.global().async也是一个逃逸闭包
        // 它用到了实例成员(属性、方法)，编译器会强制要求明确写出self DispatchQueue.global().async {}
        self.fn()
    }
}

逃逸闭包的注意点

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

typealias Fn = () -> ()

func other1(_ fn: Fn) { fn() }
func other2(_ fn: @escaping Fn) { fn() }

func test(value: inout Int) -> Fn {
    other1 { value += 1 }
    // error: 逃逸闭包不能捕获inout参数
    other2 { value += 1 }
    func plus() { value += 1 }
    // error: 逃逸闭包不能捕获inout参数
    return plus
}