20-内存管理

//内存管理1-17
/*
 1.内存管理
 跟OC一样，swift也是采取基于引用计数的ARC内存管理方案（针对堆空间）
 swift的ARC中有3种引用：
 a.强引用：默认情况下，引用都是强引用
 b.弱引用:通过weak定义弱引用，必须是可选类型的var，因为示例销毁后，ARC会自动将弱引用设置为nil，ARC自动给弱引用设置为nil时，不会触发属性观察器
 c.无主引用，通过unowned定义无主引用。
 不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似OC中的unsafe_unretained）
 试图在实例销毁后访问无主引用，会产生运行时错误（野指针）
 */
class Dog {}
class Person {
    weak var dog: Dog? {
        willSet {}
        didSet {}
    }
    deinit {
        print("Person.deinit")
    }
}
var p = Person()
p.dog = nil //不会触发属性观察器

//2.weak、unowned的使用限制:只能用在类实例上面
protocol livable : AnyObject {}
class Cat {}
weak var c1: Cat?
weak var c2: AnyObject?
weak var c3: livable?
unowned var c4: Cat?
unowned var c5: AnyObject?
unowned var c6: livable?

//3.循环引用
/*
 weak、unowned都能解决循环引用的问题，unowned要比weak少一些性能消耗,在生命周期中可能会变为nil的使用weak，初始化赋值后再也不会变为nil的使用unowned
 */
//4.闭包的循环引用
//闭包表达式默认会堆用到的外层对象产生额外的强引用（对外层对象进行了retain操作）
//下面代码会产生循环引用，导致Person对象无法释放（看不到Person的deinit被调用）
class Mouse {
    var fn : (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Mouse()
//    p.fn = {
//        p.run()
//    }
    //在闭包表达式的捕获列表声明weak或unowned引用，解决循环引用问题
//    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()
    }
}
test()

//如果想在定义闭包属性的同时引用self,这个闭包必须是lazy的（因为在实例初始化完毕之后才能引用self）
class Stone {
    lazy var fn: (() -> ()) = { //这里fn内部如果用到了实例成员(属性、方法)，编译器会强制要求明确写出self
//        self.run()
        
        //解决循环引用
//        [weak self] in //weak安全一点
//        self?.run()
        //或
        [unowned self] in
        self.run()
    }
    func run() { print("run") }
    deinit {
        print("deinit")
    }
}
func test0() {
    var p = Stone()
    p.fn()
}
test0()

//如果lazy属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的生命周期就结束了）
class Sun {
    var age: Int = 0
    lazy var getAge: Int = {
        self.age //（因为闭包调用后，闭包的生命周期就结束了,不是闭包不用写weak）
    }()
    deinit {
        print("deinit Sun")
    }
}
func test1() {
    var p = Sun()
    print(p.getAge)
}
test1()

/*
 5.@escaping
 非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数.
 非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内。
 逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明
 */
import Dispatch
typealias Fn = () -> ()
func test2(_ fn: Fn) { fn() } //fn是非逃逸闭包
var gFn: Fn?
func test3(_ fn: @escaping Fn) { gFn = fn } //fn是逃逸闭包
func test4(_ fn: @escaping Fn) {
    DispatchQueue.global().async {
        fn() //fn是逃逸闭包，有可能函数执行完了fn()才执行
    }
}
class Moon {
    var fn: Fn
    init(fn: @escaping Fn) {
        self.fn = fn //fn是逃逸闭包
    }
    func run() {
        DispatchQueue.global().async {//DispatchQueue.global().async也是一个逃逸闭包
            self.fn()//它用到了实例成员、属性、方法，编译器会强制要求明确写出self
        }
    }
}

//6.逃逸闭包的注意点
func other1(_ fn: Fn) { fn() }
func other2(_ fn: @escaping Fn) { fn() }
func test5(value: inout Int) { //打开plus时加上 -> Fn
    other1 {
        value += 1
    }
//    other2 { //编译不过 逃逸闭包不能捕获inout参数
//        value += 1
//    }
    
//    func plus() { value += 1 }
//    return plus //相当于把{ value += 1 }返回出去，那什么时候调用呢，不能确定，所以这里也是逃逸闭包
}
//理解上面编译不过的原因
func abc() {
    var num = 10
    test5(value: &num) //abc函数都执行完了，num都不存在又去捕获num肯定是不行的
}
abc()

//7.局部作用域
//可以使用do实现局部作用域
class Tiger {
    var age = 10
    func run() {}
}
do {
    let tiger1 = Tiger()
    tiger1.age = 10
    tiger1.run()
}
//从拷贝用局部作用局可防止出错
do {
    let tiger2 = Tiger()
//    tiger1.age = 10
    tiger2.run()
}

//8.内存访问冲突
/*
 至少一个是写入操作
 它们访问的是同一块内存
 它们的访问时间重叠(比如在同一个函数内)
 */
//不存在内存访问冲突
func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number)

//存在内存访问冲突
var step = 1
func increment(_ num: inout Int) {
    num += step // step读 num +=写入step 这里崩溃内存冲突
}
//increment(&step)

//解决内存访问冲突，因为读和写就不是同一块内存了
var copyOfStep = step
increment(&copyOfStep)
step = copyOfStep

//9.内存访问冲突
func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x //这里同时读写了num1，内存访问冲突
}
var num1 = 42
var num2 = 30
balance(&num1, &num2) //OK
//balence(&num1, &num1)  //Error

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) //ok
//oscar.shareHealth(with: &oscar) //error 访问的是同一个oscar

var tulpe = (health: 10, energy: 20)
//balance(&tulpe.health, &tulpe.energy) //error 访问的是同一个元组内存
var holly = Player(name: "Holly", health: 10, energy: 10)
//balance(&holly.health, &holly.energy) //error访问的是同一块结构体内存

//10.内存访问冲突
/*
 如果下边条件可以满足，就说明重叠访问结构体的属性是安全的
 a.你只访问实例存储属性，不是计算属性或类属性
 b.结构体是局部变量而非全局变量
 c.结构体要么没有被闭包捕获要么只被非逃逸闭包捕获.这里说一大堆看下面代码即可或者理解这样不报错的原因。
 */
func test6() {
    var tulpe = (health: 10, energy: 20)
    balance(&tulpe.health, &tulpe.energy)
    var holly = Player(name: "Holly", health: 10, energy: 10)
    balance(&holly.health, &holly.energy)
}

//11.指针
/*
 swift中也有专门的指针类型，这些都被定性为"Unsafe"不安全的，常见的有以下4种类型
 Un
 */
var age = 10
func open1(_ ptr: UnsafeMutablePointer<Int>) { // int *
    ptr.pointee += 10
}
func open2(_ ptr: UnsafePointer<Int>) { // const int *
    print(ptr.pointee)
}
open1(&age)
open2(&age)//20
print(age)//20

func open3(_ ptr: UnsafeMutableRawPointer) { // const void *
    ptr.storeBytes(of: 20, as: Int.self)
}
func open4(_ ptr: UnsafeRawPointer) { // void *
    print(ptr.load(as: Int.self))
}
open3(&age)
open4(&age) //20
print(age) //20

//12.指针的应用示例
import Foundation
var arr = NSArray(objects:  11, 22, 33, 44)
arr.enumerateObjects { (obj, idx, stop) in
    if idx == 2 {
        stop.pointee = true
    }
    print(idx, obj)
}
//等价推荐用下面
for (id, obj) in arr.enumerated() {
    print(id, obj)
    if id == 2 {
        break
    }
}
/*
 0 11
 1 22
 2 33
 */

//13.获得指向某个变量的指针
var ageNum = 11
var ptr1 = withUnsafeMutablePointer(to: &ageNum) { $0 } //$0表示传进来的第一个参数ageNum地址
var ptr2 = withUnsafePointer(to: &ageNum) { $0 }
ptr1.pointee = 22
print(ptr2.pointee) //22
print(ageNum) //22

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

//14.获得指向堆空间实例的指针
class Time {}
var time = Time()
var ptr = withUnsafePointer(to: &time) { UnsafeRawPointer($0) }
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self))
print(heapPtr!) //0x0000600003500590

//15.创建指针
var pt = malloc(16) //创建
pt?.storeBytes(of: 11, as: Int.self) //存前八个字节
pt?.storeBytes(of: 22, toByteOffset: 8, as: Int.self) //存后八个字节
print((pt?.load(as: Int.self))!) //11 取前八个字节
print((pt?.load(as: Int.self))!) //22 取后八个字节
free(pt)//销毁
//另外一种方式
var ptt = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ptt.storeBytes(of: 11, as: Int.self)
ptt.advanced(by: 8).storeBytes(of: 22, as: Int.self)
print(ptt.load(as: Int.self)) //11
print(ptt.advanced(by: 8).load(as: Int.self)) //22
ptt.deallocate()
//另外一种方式
var pttt = UnsafeMutablePointer<Int>.allocate(capacity: 3) //容量3
pttt.initialize(to: 11)
pttt.successor().initialize(to: 22)
pttt.successor().successor().initialize(to: 33)
print(pttt.pointee) //11
print((pttt + 1).pointee) //22
print((pttt + 2).pointee) //33
//等价
print(pttt.pointee) //11
print(pttt.successor().pointee) //22
print(pttt.successor().successor().pointee) //33
//等价
print(pttt[0]) //11
print(pttt[1]) //22
print(pttt[2]) //33
pttt.deinitialize(count: 3)
pttt.deallocate()

//16.创建指针
class Dragon {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    deinit {
        print(name,"deinit")
    }
}
var ptrr = UnsafeMutablePointer<Dragon>.allocate(capacity: 3)
ptrr.initialize(to: Dragon(age: 10, name: "Jack"))
(ptrr + 1).initialize(to: Dragon(age: 11, name: "Rose"))
(ptrr + 2).initialize(to: Dragon(age: 12, name: "Kate"))
ptrr.deinitialize(count: 3) //不写这一句3个Dragon释放不了
ptrr.deallocate()

//17.指针之间的转换 raw转pointer
var ppttrr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ppttrr.assumingMemoryBound(to: Int.self).pointee = 11 //raw转pointer再存
(ppttrr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0
print(unsafeBitCast(ppttrr, to: UnsafePointer<Int>.self).pointee) //11
print(unsafeBitCast(ppttrr + 8, to: UnsafePointer<Double>.self).pointee) //22.0
ppttrr.deallocate()
//unsafeBitCast是忽略数据类型的转换,不会因为数据类型的变化而改变原来的内存数据,类似于c++中的reinterpret_cast
//如何理解unsafeBitCast
//0x00 00 00 00 00 00 00 0A
//var age = 10
//0x01 AB 67 00 00 00 00 0A //具体存储网上查反正用科学计数什么的
//var age2 = Double(age)

//0x00 00 00 00 00 00 00 0A
var age1 = 10.0
//0x00 00 00 00 00 00 00 0A //直接将二进制数据搬过去的
var age2 = unsafeBitCast(age1, to: Int.self)

//搞一个指针变量指向堆空间的地址值
var person = Person()
var pptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(pptr) //0x0000600003ef5ca0