Swift内存管理&闭包使用

一、内存管理

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

2、Swift的ARC中有三种引用

强引用：默认情况下，引用都是强引用。
弱引用：通过weak定义弱引用。
a.必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil。
b.ARC自动给弱引用设置nil时，不会触发属性观察器。
无主引用：通过unowned定义无主引用。
a.不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的unsafe_unretained）
b.试图在实例销毁后访问无主引用，会产生运行时错误（野指针）
weak、unowned的使用限制
weak、unowned只能用在类的实例上面。

   class PersonX { }
   weak var person0 : PersonX?
   weak var person1 : AnyObject?
        
   unowned var person3 : PersonX?
   unowned var person4 : AnyObject?

二、Autoreleasepool

我们可以看出，Swift和OC的autoreleasepool使用没什么不同。

 for _ in 0...5000 {
     autoreleasepool {                
     }
 }

三、循环引用

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

a.生命周期中可能会变为nil的使用weak。
b.初始化赋值后再也不会变为nil的使用unowned。
c.这里有疑问，等到后面补充一下：

四、闭包循环引用

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

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

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

错误调用：

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

修正方法：

  func test() {
            let p = PersonY()
            p.fn = { [weak p] in
                    //或者[unowned p] in
                p!.run()
            }
        }
   test()

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

下面的闭包fn(Method)内部如果用到了实例成员（属性、方法），编译器会强制要求明确写出self。如果不写，会有如下错误：
Call to method 'run' in closure requires explicit 'self.' to make capture semantics explicit(在闭包中调用方法“run”需要显式的“self”)

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

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

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

五、@escaping

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

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

a.首先声明一个闭包类型：

typealias Fn = () -> ()

b.fn是非逃逸闭包

func test1(_ fn: Fn) {
    fn()
}

c.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()
    }
}

d.逃逸闭包注意点：
逃逸闭包不可以捕获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
}

最后编辑于：2019.12.12 09:50:34