/**Swift 使用自动引用计数ARC机制来跟踪和管理内存。通常情况下都是自动管理，但在极少数情况下，为了能帮助你管理内存，ARC需要更多的代码之间关系的信息。
    引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递
 
 工作机制：
    1.每次创建类的实例时，ARC会分配一块内存来存储该实例信息；当实例不在使用时，ARC释放实例所占用的内存，并让释放的内存能挪作他用。
    2.但当ARC收回和释放了正在被使用中的实例，该实例的属性和方法将不能b再被访问和调用。实际上如果你试图访问这个实例，程序可能会崩溃。
    3.为确保使用中的实例不会被销毁，ARC会跟踪和计算每一个实例正在被多少属性、常量和变量所引用，引用数为0时才会销毁这个实例。
    4.无论你讲实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称为“强”引用，是因为它们会将实例牢牢地保持住，只要强引用还在，实例时不允许被销毁的。
 */
//自动引用计数的实践
class Person18 {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name)初始化了")
    }
    
    deinit {
        print("\(name)被销毁了")
    }
}
var reference1: Person18?
var reference2: Person18?
var reference3: Person18?
//上方的三个变量都是可选类型，它们的值会被自动初始化为nil，目前还不会引用到Person类的实例
reference1 = Person18(name: "加菲尔德") //构造函数被执行了，reference1与Person类之间有了一个强引用
reference2 = reference1 //第二个强引用
reference3 = reference1 // 第三个强引用
reference1 = nil//断开了一个强引用
reference2 = nil//断开了第二个强引用
reference3 = nil//断开所有的强引用后，ARC才会销毁这个Person实例，deinit中的打印才会执行


//类实例之间的循环强引用
//循环强引用：两个类实例互相持有对方的强引用，导致类实例的强引用数永远不嫩变成0；
//可以通过定义类之间的关系为弱引用或无主引用，以替代强引用，从而解决循环强引用的问题
class PersonY {//人
    let name: String//每个人都有一个名字
    init(name: String) { self.name = name }
    var apartment: Apartment? //但不是每个人都有一套公寓
    deinit {
        print("PersonY实例\(name)被销毁了")
    }
}
class Apartment {//公寓
    let unit: String //每个公寓都有一个单元门牌号
    init(unit: String) { self.unit = unit }
//    var tenant: PersonY?//如果这样写，会导致循环引用
    weak var tenant: PersonY?//而前面加一个weak就会打破这种强引用（注意：playground中可能演示不出来，请在项目中演示）
    deinit {
        print("Apartment实例的\(unit)被销毁了")
    }
}

var john: PersonY?
var unit4A: Apartment?
//上面两个实例变量的初始化值都为nil
john = PersonY(name: "约翰") //变量john有一个指向Person实例的强引用
unit4A = Apartment(unit: "A406") //变量unitA406有一个指向Apartment实例的强引用

john!.apartment = unit4A // john有公寓住了;！是用来展开和访问可选变量john中的实例的，这样实例的属性才能被赋值
unit4A!.tenant = john //公寓里也有人住了;！是用来展开和访问可选变量unitA406中的实例的，这样实例的属性才能被赋值
//此时，产生了一个循环强引用；PersonY实例有了一个指向Apartment实例的强引用；而Apartment实例也有了一个指向PersonY实例的强引用
john = nil
unit4A = nil
//两个变量都置为nil了，但没有任何一个析构函数被调用，循环引用会一直阻止Person和Apartment实例的销毁，这就会造成内存泄漏


/**解决实例之间的循环强引用
    Swift提供了两种办法用来解决循环强引用的问题：弱引用 和 无主引用
    当其他实例有更短的生命周期（析构在先）时，使用弱引用；当其他实例有相同的或者更长生命周期时，用无主引用。
    上面的例子中，公寓在声明周期内会在某个时间段没有居民，所以弱引用就加在公寓类里面。
 
*弱引用：在前面加关键字weak；不会保持所引用的实例，即使引用存在，实例也有可能被销毁，因此,ARC会在引用的实例被销毁后自动将其赋值为nil;
     弱引用允许他们的值在运行时被赋值为nil，所以它们会被定义为可选类型变量，而不是常量；
     当ARC设置弱引用为nil时，属性观察不会被触发。
     以上例子中，可以在Apartment中奖Person的实例变量定义为Wear类型来破出循环引用： weak var tenant: PersonY?
 */
/**无主引用：在前面加关键字unowned;无主引用不会牢牢保持住引用的实例，和弱引用不同的是，无主引用在其他实例有相同或者更长的生命周期时使用。
    无主引用通常都被期望拥有值，不过ARC无法在实例被销毁后将无主引用设为nil；因为非可选类型的变量不允许被赋值为nil
    使用无主引用，必须确保引用始终指向一个未销毁的实例；如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。
*/
class Customer {//客户
    let name: String
    var card: CreditCard?//可能有张信用卡
    init(name: String) {
        self.name = name
    }
    deinit {
        print("Customer类中的\(name)被干掉了")
    }
}
class CreditCard {//信用卡
    let number: UInt64 //确保不管是在32位系统还是64位系统都能够容纳16位的卡号
    unowned let customer: Customer //每张信用卡总是关联着一个客户，因此将customer属性定义为无主引用，以避免循环强引用
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit {
        print("CreditCard类中的\(number)被干掉了")
    }
}
var durex: Customer?
durex = Customer(name: "杜丽莎")
durex!.card = CreditCard(number: 1314520866660520, customer: durex!)
//Customer实例对CreditCard实例持有强引用；CreditCard实例对Customer实例持有无主引用
durex = nil//俩实例都销毁了

/**无主引用以及隐式解析可选属性
    1.weak的例子中，两个属性的值都允许为nil，这种场景最适合用弱引用来解决；
    2.unowned的例子中，一个属性的值允许为nil，另一个属性的值不允许为nil，这种场景适合通过无主引用来解决；
    3.若两个属性都必须有值，并且初始化完成后永远不会为nil，这种场景下，就需要一个类使用无主属性，另一个类使用隐式解析可选属性；
 */
class Country { //国家
    let name: String //国名
    var capitalCity: City! //必须有一个城市是首都；通过在类型结尾处加上！的方式将属性声明为 隐式解析可选类型的属性；capitalCity属性的默认值是nil
    init(name: String, capitalName: String) {
        self.name = name
        self.capitalCity = City(name: capitalName, country: self)
    }
    deinit {
        print("Country类中的\(name)被干掉了")
    }
}
class City { //城市
    let name: String //城市名称
    unowned let country: Country //城市属于一个国家
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
    deinit {
        print("City类中的\(name)被干掉了")
    }
}
var country = Country(name: "加拿大", capitalName: "温哥华")
print("\(country.capitalCity.name)是\(country.name)的首都")


/**闭包引起的循环强引用
    闭包和类相似，都是引用类型，当你把一个闭包赋值给某个属性时，你是讲这个闭包的引用赋值给了属性。
    当你讲一个闭包赋值给类实例的某个属性，并且这个闭包体中可能访问了实例的某个属性或调用了实例的某个方法时，会产生循环强引用。
    Swift 提供了一种优雅的方法来解决这个问题，称之为 闭包捕获列表（closure capture list）
 */
class HTMLElement { // HTML文档中的一个单独的元素
    let name: String //表示元素的名称
    let text: String? //可选属性，代表呈现的文本
    lazy var asHTML: () -> String = { //懒加载一个属性asHTML，该属性是() -> String 类型 引用了一个闭包
        [unowned self] in //加了一个捕获列表，这里用无主引用，表示 将self捕获为无主引用而不是强引用；
        if let text = self.text { //如果text值存在，就返回包含text的文本
            return "<\(self.name)>\(text)</\(self.name)>" //加了捕获列表，捕获了self并不会持有HTMLElement实例的强引用
        } else { // 否则返回不包含text文本的
            return "<\(self.name)>"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    
    deinit {
        print("HTMLElement类中的\(name)销毁了")
    }
}

let heading = HTMLElement(name: "hl")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print("htmlTlement类的演示1：\(heading.asHTML())")

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print("htmlTlement类的演示2：\(paragraph!.asHTML())")
//上面分析为：实例的asHTML属性持有闭包的强引用，但是闭包在其闭包体内使用了self(引用了self.name和self.text)，因此闭包捕获了self,这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。虽然闭包多次使用了self,但它值捕获了HTMLElement实例的一个强引用。  paragraph变量定义为可选类型，因此可以赋值为nil来演示循环强引用
paragraph = nil //HTMLElement实例和它的闭包都不会被销毁，因为循环强引用的存在

/**解决闭包引起的循环强引用
    定义闭包的同时，定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。
    捕获列表定义了闭包体内捕获一个或多个引用类型的规则，跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。
    捕获列表中的每一项都由一对元素组成，一个元素是weak或unowned关键字，另一个元素是类实例的引用或初始化过的变量（如delegate = self.delegate!），这些项在方括号中用逗号分开。

 lazy var someClosureBuHuo: (Int, String) -> String = {
 //如果闭包有参数列表和返回类型，把捕获列表放在它们前面
 [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
 //如果闭包没有指明参数列表或返回类型（会通过上下文推断），那么可以把捕获列表和关键字in放在闭包最开始的地方：
 [unowned self, weak delegate = self.delegate!] in
 //这里是闭包的函数体
 }
 
 */
//弱引用和无主引用：闭包内捕获的引用绝对不会变为nil时，应该用无主引用；其他情况下用弱引用。