Swift基础知识之内存管理(一)

一、内存管理

  • 跟OC一样,Swift也是采取基于引用计数的ARC内存管理方案(针对堆空间)
  • Swift的ARC中有3种引用
    • 强引用(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
class Person {}
//'weak' must be a mutable variable, because it may change at runtime
weak let age = Person()

二、weak、unowned的使用限制

  • 不能修饰值类型
// 'weak' may only be applied to class and class-bound protocol types, not 'Int'
weak let age = 10
  • weak、unowned只能用在类实例上面
protocol Livable : AnyObject {}
class Person {}

weak var p0: Person?
weak var p1:AnyObject?
// 这里是因为Livable必须是类才能实现的协议
weak var p2: Livable?

unowned var up0: Person?
unowned var up1: AnyObject?
unowned var up2: Livable?

三、Autoreleasepool

  • autoreleasepool 函数
public func autoreleasepool(invoking body: () throws -> Result) rethrows -> Result
  • 使用
class Person {
    var age: Int?
    var name: String?
    func run() {
        print("name is haha")
    }
    deinit {
        print("Person deinit")
    }
}

autoreleasepool {
    let p = Person()
    p.name = "JJJ"
    p.age = 10
    p.run()
}

四、循环引用(Reference Cycle)

1. 循环引用
  • 下面代码会产生循环引用,导致Person对象无法释放
class Person {
    var fn: ( () -> () )?
    func run() {
        print("Person run")
    }
    deinit {
        print("Person deinit")
    }
}

func test() {
    let p = Person()
    p.fn = {
        p.run()
    }
}
2. 循环引用的解决
  • weak、unowned都能解决循环引用的问题,unowned要比weak少一些性能消耗
    • 在生命周期中可能会变成nil的使用weak
    • 初始化赋值后再也不会变为nil的使用unowned
3. 闭包的循环引用
  • 闭包表达式默认会对用到的外层对象产生额外的强引用(对外层对象进行了retain操作)
  • 在闭包表达式的捕获列表声明weak、unowned引用,解决循环引用问题
func test() {
    let p = Person()
    p.fn = {
        // [unowned p] in
        [weak p] in
        // p 这里可能为空、所以要加上?
        p?.run()
    }
}

func test() {
    let p = Person()
    p.fn = {
        // 可以捕获多个变量、并且可以重写命名
        [weak wp = p, unowned ups = p, a = 10 + 20] in
        wp?.run()
    }
}
  • 如果想在定义闭包属性的同时引用self,这个闭包必须是lazy的(因为在实例初始化完毕之后才能应用self)
  • 这种lazy的闭包内部,如果用到了实例成员(属性、方法)
  • 编译器会强制要求明确写出self
class Person {
    lazy var fn: ( () -> () ) = {
        [weak self] in
        // 编译器会强制要求明确写出self,
        // 相当于提示这里可能会出现循环引用
        self?.run()
    }
    
    func run() {
        print("Person run")
    }
    deinit {
        print("Person deinit")
    }
}
  • 如果lazy属性是闭包调用的结果,那么不用考虑循环引用的问题(因为闭包调用后,闭包的生命周期就结束了)
class Person {
    var age: Int = 0
    
    lazy var getAge: Int = {
        self.age
    }()
    
    deinit {
        print("Person deinit")
    }
}
4.@escaping
  • 非逃逸闭包、逃逸闭包,一般都是当做参数传递给函数
  • 非逃逸闭包: 闭包调用发生在函数调用结束前,闭包调用在函数作用域内
  • 逃逸闭包:闭包有可能在函数结束后调用,闭包调用逃离了函数的作用域,需要用@escaping声明
typealias Fn = () -> ()
// 非逃逸闭包
func test1(_ fn: Fn) { fn() }
// 逃逸闭包
var gFn: Fn?
func test2(_ fn: @escaping Fn) { gFn = fn }
class Person {
    var fn: Fn

    init(fn: @escaping Fn) {
        self.fn = fn
    }
    func run() {
        DispatchQueue.global().async {
           // 它用到了实例成员(属性、方法),编译器会强制要求明确写self
            self.fn()
        }
    }
}
5. 逃逸闭包注意点
  • 逃逸闭包不可以捕获inout参数
func test(value: inout Int) -> Fn {
    other1 {
        value += 1
    }
    // Escaping closure captures 'inout' parameter 'value'
    other2 {
        value += 1
    }
    // Escaping local function captures 'inout' parameter 'value'
    func plus() { value += 1 }
    return plus
}

五、内存访问冲突(Conflicting Access to Memory)

  • 内存访问冲突会在两个访问满足下列条件时发生
    • 至少一个是写入操作
    • 他们访问的是同一块内存
    • 他们的访问时间重叠(比如在一个函数内)
var step = 1
func increment(_ num: inout Int) {
    num += step
}
//Thread 1: Simultaneous accesses to 0x10000c548, but modification requires exclusive access
increment(&step)
  • 解决冲突
var copyStep = step
increment(©Step)
step = copyStep
func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}

var num1 = 10
var num2 = 5

balance(&num1, &num2) // 不会冲突
//inout arguments are not allowed to alias each other
balance(&num1, &num1) // 会冲突
  • 如果下面条件满足,就说明重叠访问结构体的属性是安全的
    • 只访问了实例存储属性,不是计算属性或者类属性
    • 结构体是局部变量而非全局变量
    • 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获
// 局部作用域下可以
func tests() {
    var tulpe = (health: 10, energy: 20)
    balance(&tulpe.health, &tulpe.energy)
}

本次swift内存管理知识先写到这里、持续更新中,如有不当之处还请各位大神批评指正,不胜感激!!!

你可能感兴趣的:(Swift基础知识之内存管理(一))