Swift－析构方法与内存管理（初级）

Swift析构方法与内存管理（初级）

/*
    Swift 内存管理（只有ARC模式，没有MRC模式，不需要手动管理内存，系统自动管理）
 */

import Foundation

/*
  1、析构方法
    对象的内存被回收前被隐式调用的方法。主要执行一些额外的操作。比如：关闭文件、断开网络、释放对象等
    ARC，弱化内存操作（Swift的析构方法，不用管理内存）
 */
print("1、析构方法")
class FileHandler{
    var fd:Int32?
    init(path:String) {
        let ret = open(path, O_RDONLY)
        if (ret == -1) {
            fd = nil
        }
        else
        {
            fd = ret
        }
    }
    //deinit关键字（析构方法，对应构造方法，与构造方法形成一个生命周期）
    deinit {
        if let ofd = fd {
            close(ofd)
        }
        print("对象被销毁，持有资源被释放")
    }
}
var ofh:FileHandler? = FileHandler(path:"etc/passwd")
//目前无任何引用指向当前构造的对象
ofh = nil

/*
 2、析构方法的自动继承：父类的析构方法会被自动调用，不需要子类管理）
 */
print("\n2、析构方法的自动继承")
class someClasee {
    deinit {
        print("someClasee deinit")
    }
}
class subClass: someClasee {
    deinit {
        print("subClass deinit")
    }
}
var sub:subClass? = subClass()
sub = nil

/*
 3、Swift语言内存管理
  （1）内存管理对象：引用类型对象（class类型）
  （2）内存管理原则：没有任何引用指向某个对象的时候，系统会自动销毁该对象
  （3）通过ARC技术实现
 */
print("\n3、Swift语言内存管理")
class MemARC {
    deinit {
        print("MemARC deinit")
    }
}
var mem1 = MemARC()
var mem2 = mem1
var mem3 = MemARC()
mem1 = mem3
mem2 = mem3

/*
 4、weak弱引用
 */

/*
 5、unowned弱引用
 */
print("\n4、weak弱引用")
print("5、unowned弱引用")
class Ref {
    deinit {
        print("Ref deinit")
    }
    func test() {
        print("test")
    }
}

//强引用，默认的引用方式
var strongRef = Ref()
//weak引用（安全引用,不会持有该对象，对象销毁时系统会自动将当前对象置为nil）
//弱引用一定是一个可选类型
weak var weakRef:Ref? = Ref()
if let we = weakRef{
    we.test()
}

//弱引用（不是一个可选类型）
unowned var unRef:Ref = Ref()
//unRef.test()//这是不安全的，给一个已经被释放掉的对象发送一个消息（运行时报错）

/*
 6、循环强引用
 解决：其中一个对象置为弱引用
 (ARC非万能，在某些情况下不能很好的解决内存泄漏问题)
 */
print("\n6、循环强引用")
class Person {
    let name:String
    init(name:String) {
        self.name = name
    }
    var apartment:Apartment?
    deinit {
        print("\(name) is being deinit")
    }
}
class Apartment {
    let number:Int
    init(number:Int) {
        self.number = number
    }
    //针对两个对象之间的相互循环强引用，使用weak弱引用可以销毁两个对象，解决两对象相互强引用造成的内存泄漏
    weak var teant:Person?
    deinit {
        print("Apartment #\(number) is being deinit")
    }
}

var john:Person?
var number73:Apartment?

john = Person(name:"John Apple")
number73 = Apartment(number:73)

john!.apartment = number73
number73!.teant = john

//两个对象没有被销毁，但是依然不能对两对象进行访问（内存泄漏）
john = nil
number73 = nil

/*
 7、unowned解决循环强引用
 */
print("\n7、unowned解决循环强引用")
class Customer {
    let name:String
    var card:CreditCard?
    init(name:String) {
        self.name = name
    }
    deinit {
        print("\(name) is being deinit")
    }
}

class CreditCard {
    let number:UInt64
    //unowned解决循环强引用
    unowned let customer:Customer
    init(number:UInt64,customer:Customer) {
        self.number = number
        self.customer = customer
    }
    deinit {
        print("Card #\(number) is being deinit")
    }
}

var tom:Customer?
tom = Customer(name:"Tom Apple")
tom!.card = CreditCard(number:32797979668768,customer:tom!)
tom = nil