内存管理

2020-05-19  本文已影响0人  Stago

内存管理

强引用(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

weak、unowned的使用限制

protocol Livable: AnyObject {}
class Person {}

weak var p0: Person?
weak var p1: AnyObject?
weak var p2: Livable?

unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Livable?

Autoreleasepool

public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result
autoreleasepool {
    let p = Person(age: 20, name: "Jack")
    p.run()
}

循环引用(Reference Cycle)

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

闭包的循环引用

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    p.fn = { p.run() }
}
test()
p.fn = {
    [weak p] in
    p?.run()
}
p.fn = {
    [unowned p] in
    p.run()
}
p.fn = {
    [weak wp = p, unowned up = p, a = 10 + 20] in
    wp?.run()
}
class Person {
    lazy var fn: (() -> ()) = {
        [weak self] in
        self?.run()
    }
    func run() { print("run") }
    deinit { print("deinit") }
}

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

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

@escaping

import Dispatch
typealias Fn = () -> ()

// fns是非逃逸闭包
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()
        }
    }
}

逃逸闭包的注意点

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

至少一个是写入操作
它们访问的是同一块内存
它们的访问时间重叠(比如在同一个函数内)

// 不存在内存访问冲突
func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number)

// 存在内存访问冲突
// error: Simultaneous accesses to 0x100002028, but modification requires exclusive access
var step = 1
func increment(_ num: inout Int) { num += step}
increment(&step)

// 解决内存访问冲突
var copyOfStep = step
increment(&copyOfStep)
step = copyOfStep
func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
var num1 = 42
var num2 = 30
balance(&num1, &num2) // OK
balance(&num1, &num1) // error: Inout arguments are not allowed to alias each other
struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}


var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria)
oscar.shareHealth(with: &oscar) // error: Inout arguments are not allowed to alias each other
var tuple = (health: 10, energy: 20)
// error: Simultaneous accesses to 0x100003090, but modification requires exclusive access
balance(&tuple.health, &tuple.energy)

var holly = Player(name: "Holly", health: 10, energy: 10)
//error: Simultaneous accesses to 0x1000030a0, but modification requires exclusive access
balance(&holly.health, &holly.energy)
  • 你只访问实例存储属性,不是计算属性或者类属性
  • 结构体是局部变量而非全局变量
  • 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获
// OK
func test() {
    var tuple = (health: 10, energy: 20)
    balance(&tuple.health, &tuple.energy)

    var holly = Player(name: "Holly", health: 10, energy: 10)
    balance(&holly.health, &holly.energy)
}
test()

指针

UnsafePointer<Pointee> 类似于 const Pointee *
UnsafeMutablePointer<Pointee> 类似于 Pointee *
UnsafeRawPointer 类似于 const void *
UnsafeMutableRawPointer 类似于 void *

var age = 10
func test1(_ ptr: UnsafeMutablePointer<Int>) {
    ptr.pointee += 10
}
func test2(_ ptr: UnsafePointer<Int>) {
    print(ptr.pointee)
}
test1(&age)
test2(&age) // 20
print(age) // 20
var age = 10
func test3(_ ptr: UnsafeMutableRawPointer) {
    ptr.storeBytes(of: 20, as: Int.self)
}
func test4(_ ptr: UnsafeRawPointer) {
    print(ptr.load(as: Int.self))
}
test3(&age) // 20
test4(&age) // 20
print(age)

指针的应用示例

var arr = NSArray(objects: 11, 22, 33, 44) arr.enumerateObjects { (obj, idx, stop) in
    print(idx, obj)
    if idx == 2 { // 下标为2就停止遍历
        stop.pointee = true
    }
}
var arr = NSArray(objects: 11, 22, 33, 44) for (idx, obj) in arr.enumerated() {
    print(idx, obj)
    if idx == 2 {
        break
    }
}

获得指向某个变量的指针

var age = 11
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 }
var ptr2 = withUnsafePointer(to: &age) { $0 }
ptr1.pointee = 22
print(ptr2.pointee) // 22
print(age) // 22

var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) }
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) }
ptr3.storeBytes(of: 33, as: Int.self)
print(ptr4.load(as: Int.self)) // 33
print(age) // 33

获得指向堆空间实例的指针

class Person {}
var person = Person()
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0) }
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self))
print(heapPtr!)

创建指针

var ptr = UnsafeRawPointer(bitPattern: 0x100001234)
// 创建
var ptr = malloc(16)
// 存
ptr?.storeBytes(of: 11, as: Int.self)
ptr?.storeBytes(of: 22, toByteOffset: 8, as: Int.self)
// 取
print((ptr?.load(as: Int.self))!) // 11 print((ptr?.load(fromByteOffset: 8, as: Int.self))!) // 22
// 销毁
free(ptr)
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) 
ptr.storeBytes(of: 11, as: Int.self)
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self) print(ptr.load(as: Int.self)) // 11
print(ptr.advanced(by: 8).load(as: Int.self)) // 22 ptr.deallocate()
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3) ptr.initialize(to: 11)
ptr.successor().initialize(to: 22) ptr.successor().successor().initialize(to: 33)
print(ptr.pointee) // 11 
print((ptr + 1).pointee) // 22
print((ptr + 2).pointee) // 33
print(ptr[0]) // 11
print(ptr[1]) // 22
print(ptr[2]) // 33
ptr.deinitialize(count: 3) 
ptr.deallocate()
class Person {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    deinit { print(name, "deinit") }
}
var ptr = UnsafeMutablePointer<Person>.allocate(capacity: 3)
ptr.initialize(to: Person(age: 10, name: "Jack"))
(ptr + 1).initialize(to: Person(age: 11, name: "Rose"))
(ptr + 2).initialize(to: Person(age: 12, name: "Kate"))
// Jack deinit
// Rose deinit
// Kate deinit
ptr.deinitialize(count: 3)
ptr.deallocate()

指针之间的转换

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)

ptr.assumingMemoryBound(to: Int.self).pointee = 11
(ptr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0

print(unsafeBitCast(ptr, to: UnsafePointer<Int>.self).pointee) // 11
print(unsafeBitCast(ptr + 8, to: UnsafePointer<Double>.self).pointee) // 22.0

ptr.deallocate()

类似于C++中的reinterpret_cast

class Person {}
var person = Person()
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self) 
print(ptr)
上一篇 下一篇

猜你喜欢

热点阅读