Swift里自动引用计数

目录

自动引用计数（ARC）

自动引用计数的工作机制（引用计数器为0时才释放对象

自动引用计数实践（赋值增加一次强引用，赋值对象设置为nil减少一次

类实例之间的循环强引用（两个类相互持有对方的强引用

 解决实例之间的循环强引用（弱引用(weak) 和无主引用 (unowned

弱引用 (声明前加 weak 关键字，类型要求定义为可选型

无主引用（声明前加关键字 unowned，主对象释放无主引用的对象也释放

无主引用和隐式解包可选值属性 (类型后加 '!'，属性声明为隐式解包可选值类型

闭包的循环强引用（self强持有闭包属性, 闭包实现里又强引用self属性

解决闭包的循环强引用

定义捕获列表 （ [unowned self, weak delegate = self.delegate]

弱引用和无主引用 (可能为nil时用弱引用，捕获的值和闭包同时销毁用无主引用unown

---

自动引用计数（ARC）

Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。ARC 会在类的实例不再被使用时，自动释放其占用的内存 Swift 使用 ARC 与在 Obejctive-C 中使用 ARC 非常类似

自动引用计数的工作机制（引用计数器为0时才释放对象

ARC 回收并释放了正在被使用中的实例后，该实例的属性和方法将不能再被访问和调用。如果试图访问这个实例，你的应用程序很可能会崩溃。

为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为 1，ARC 都不会销毁这个实例。

无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用，是因为它会将实例牢牢地保持住，只要强引用还在，实例是不允许被销毁的。

自动引用计数实践（赋值增加一次强引用，赋值对象设置为nil减少一次

class Person {
    let name: String
    init(name: String) { 构造器
        self.name = name
        print("\(name) is being initialized")
    }
    deinit { 析构器
        print("\(name) is being deinitialized")
    }
}

var reference1: Person?
var reference2: Person?
var reference3: Person?
//值会被自动初始化为 nil，目前还不会引用到 Person 类的实例


reference1 = Person(name: "John Appleseed") 
// 打印“John Appleseed is being initialized” 构造器被执行
 Person 类的新实例被赋值给了 reference1 变量，
所以 reference1 到 Person 类的新实例之间建立了一个强引用。正是因为这一个强引用，
ARC 会保证 Person 实例被保持在内存中不被销毁。

reference2 = reference1
reference3 = reference1
//现在这一个 Person 实例已经有三个强引用了。

reference1 = nil
reference2 = nil

reference3 = nil
// 打印“John Appleseed is being deinitialized”
第三个也就是最后一个强引用被断开时，ARC 会销毁它

最后一个强引用被断开时，ARC 会销毁创建的实例

类实例之间的循环强引用（两个类相互持有对方的强引用

ARC 会跟踪你所新创建的 Person 实例的引用数量，并且会在 Person 实例不再被需要时销毁它

如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的循环强引用。你可以通过定义类之间的关系为弱引用或无主引用，来替代强引用，从而解决循环强引用的问题。

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment? //强持有Apartment
    deinit { print("\(name) is being deinitialized") }
}

//公寓
class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person? //强持有Person
    deinit { print("Apartment \(unit) is being deinitialized") }
}javascript:void(0)

初始化并赋值

var john: Person?
var unit4A: Apartment?

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
 john 现在有一个指向 Person 实例的强引用，而变量 unit4A 有一个指向 Apartment 实例的强引用

将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客
john!.apartment = unit4A
unit4A!.tenant = john
感叹号是用来展开和访问可选变量 john 和 unit4A 中的实例，这样实例的属性才能被赋值

强引用的关系如图

这两个实例关联后会产生一个循环强引用。Person 实例现在有了一个指向 Apartment 实例的强引用，而 Apartment 实例也有了一个指向 Person 实例的强引用。因此，当你断开 john 和 unit4A 变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：

john = nil
unit4A = nil

// 未打印任何日志，说明 都没有被释放！

将 john 和 unit4A 赋值为 nil 后，强引用关系如下图：

 解决实例之间的循环强引用（弱引用(weak) 和无主引用 (unowned

Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（weak reference）和无主引用（unowned reference）

弱引用和无主引用允许循环引用中的一个实例引用另一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用

当其他的实例有更短的生命周期时，使用弱引用，也就是说，当其他实例析构在先时。在上面公寓的例子中，很显然一个公寓在它的生命周期内会在某个时间段没有它的主人，所以一个弱引用就加在公寓类里面，避免循环引用。相比之下，当其他实例有相同的或者更长生命周期时，请使用无主引用

弱引用 (声明前加 weak 关键字，类型要求定义为可选型

弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时，在前面加上 weak 关键字表明这是一个弱引用。

因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其弱引用赋值为 nil。并且因为弱引用需要在运行时允许被赋值为 nil，所以它们会被定义为可选类型变量，而不是常量

当 ARC 设置弱引用为 nil 时，属性观察 (willSet 和 didSet 两实现) 不会被触发 

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment? //一个人并不总是拥有公寓用 ？
    deinit { print("\(name) is being deinitialized") }
}

//公寓
class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person? //weak 指定为弱引用
    deinit { print("Apartment \(unit) is being deinitialized") }
}

//赋值
var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

//释放
john = nil
//打印： John Appleseed is being deinitialized

由于再也没有指向 Person 实例的强引用，该实例会被销毁，且 tenant 属性会被赋值为 nil：

剩下的指向 Apartment 实例的强引用来自于变量 unit4A。如果你断开这个强引用，再也没有指向 Apartment 实例的强引用了 

unit4A = nil
// 打印“Apartment 4A is being deinitialized”

无主引用（声明前加关键字 unowned，主对象释放无主引用的对象也释放

和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用在其他实例有相同或者更长的生命周期时使用。你可以在声明属性或者变量时，在前面加上关键字 unowned 表示这是一个无主引用

无主引用通常都被期望拥有值。不过 ARC 无法在实例被销毁后将无主引用设为 nil，因为非可选类型的变量不允许被赋值为 nil

使用无主引用，你必须确保引用始终指向一个未销毁的实例。如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。

示例：

Customer 和 CreditCard，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。

Customer 和 CreditCard 之间的关系与前面弱引用例子中 Apartment 和 Person 的关系略微不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，Customer 类有一个可选类型的 card 属性，但是 CreditCard 类有一个非可选类型的 customer 属性。

//用户
class Customer {
    let name: String
    var card: CreditCard? //对 CreditCard 实例的强引用
    init(name: String) {
        self.name = name
    }
    deinit { print("Customer \(name) is being deinitialized") }
}

//信用卡
class CreditCard {
    let number: UInt64 //UInt64确保存储量在32位和64位系统上都能足够容纳16位的卡号
    unowned let customer: Customer //Customer 实例的无主引用。
    
    //构造器确保当创建 CreditCard 实例时总是有一个 customer 实例与之关联
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

初始化赋值

var johnAppleseed: Customer?
johnAppleseed = Customer(name: "John Appleseed")
johnAppleseed!.card = CreditCard(number: 1234_5678_9012_3456, customer: johnAppleseed!)

由于 customer 的无主引用，当你断开 john 变量持有的强引用时，再也没有指向 Customer 实例的强引用了：

由于再也没有指向 Customer 实例的强引用，该实例被销毁了。其后，再也没有指向 CreditCard 实例的强引用，该实例也随之被销毁了

释放
johnAppleseed = nil
//打印 ： Customer John Appleseed is being deinitialized
//打印 ： Card #1234567890123456 is being deinitialized

Customer 实例和 CreditCard 实例的析构器都打印出了“销毁”的信息。

上面的例子展示了如何使用安全的无主引用。对于需要禁用运行时的安全检查的情况（例如，出于性能方面的原因），Swift 还提供了不安全的无主引用。与所有不安全的操作一样，你需要负责检查代码以确保其安全性。 你可以通过 unowned(unsafe) 来声明不安全无主引用。如果你试图在实例被销毁后，访问该实例的不安全无主引用，你的程序会尝试访问该实例之前所在的内存地址，这是不安全的操作

无主引用和隐式解包可选值属性 (类型后加 '!'，属性声明为隐式解包可选值类型

Person 和 Apartment 的例子展示了两个属性的值都允许为 nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。

Customer 和 CreditCard 的例子展示了一个属性的值允许为 nil，而另一个属性的值不允许为 nil，这也可能会产生循环强引用。这种场景最适合通过无主引用来解决

第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为 nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解包可选值属性

这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用

示例：

//每个国家必须有首都，每个城市必须属于一个国家

class Country {
    let name: String
    var capitalCity: City! //拥有 capitalCity 属性 声明为 隐式解包可选值类型的属性

//构造器调用了 City 的构造器。
//只有 Country 的实例完全初始化后，Country 的构造器才能把 self 传给 City 的构造器
    init(name: String, capitalName: String) {
        self.name = name
        self.capitalCity = City(name: capitalName, country: self)
    }
}

class City {
    let name: String
    unowned let country: Country //有一个 country 属性：

    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

只有 Country 的实例完全初始化后，Country 的构造器才能把 self 传给 City 的构造器。

为满足这种需求，在类型结尾处加上感叹号（City!）的方式，将 Country 的 capitalCity 属性声明为隐式解包可选值类型的属性。这意味着像其他可选类型一样，capitalCity 属性的默认值为 nil，但是不需要展开它的值就能访问它。（理解用! 解包了，所以不用解包就可以访问）

由于 capitalCity 默认值为 nil，一旦 Country 的实例在构造器中给 name 属性赋值后，整个初始化过程就完成了。这意味着一旦 name 属性被赋值后，Country 的构造器就能引用并传递隐式的 self。Country 的构造器在赋值 capitalCity 时，就能将 self 作为参数传递给 City 的构造器。

意义在于你可以通过一条语句同时创建 Country 和 City 的实例，而不产生循环强引用，并且 capitalCity 的属性能被直接访问，而不需要通过感叹号来展开它的可选值：

var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// 打印“Canada's capital city is called Ottawa”

闭包的循环强引用（self强持有闭包属性, 闭包实现里又强引用self属性

循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了这个类实例时。这个闭包体中可能访问了实例的某个属性

循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你是将这个闭包的引用赋值给了属性。实质上，这跟之前的问题是一样的——两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。

Swift 提供了一种优雅的方法来解决这个问题，称之为 闭包捕获列表（closure capture list）

class HTMLElement {
    let name: String
    let text: String?

    //asHTML属性是: Void -> String类型(“一个没有参数，返回 String 的函数”)
    lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }

}

//将一个闭包赋值给 asHTML 属性，这个闭包能在 text 属性是 nil 时使用默认文本，这是为了避免返回一个空的 HTML 标签：
let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())
// 打印“<h1>some default text</h1>”

不幸的是，上面写的 HTMLElement 类产生了类实例和作为 asHTML 默认值的闭包之间的循环强引用。循环强引

实例的 asHTML 属性持有闭包的强引用。但是，闭包在其闭包体内使用了 self（引用了 self.name 和 self.text），因此闭包捕获了 self，这意味着闭包又反过来持有了 HTMLElement 实例的强引用。这样两个对象就产生了循环强引用。(类似OC里的Block的循环引用) 

设置 paragraph 变量为 nil，打破它持有的 HTMLElement 实例的强引用，HTMLElement 实例和它的闭包都不会被销毁，也是因为循环强引用：

paragraph = nil
析构器中的消息并没有被打印，证明了 HTMLElement 实例并没有被销毁。

解决闭包的循环强引用

在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。

Swift 有如下要求：只要在闭包内使用 self 的成员，就要用 self.someProperty 或者 self.someMethod()（而不只是 someProperty 或 someMethod()）。这提醒你可能会一不小心就捕获了 self（ OC里block里要用self.去访问变量而不是成员变量的方式）

定义捕获列表 （ [unowned self, weak delegate = self.delegate]

捕获列表中的每一项都由一对元素组成，一个元素是 weak 或 unowned 关键字，另一个元素是类实例的引用

    lazy var someClosure = {
        [unowned self, weak delegate = self.delegate] //定义捕获列表
        
        (index: Int, stringToProcess: String) -> String in
        // 这里是闭包的函数体
    }

如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字 in 放在闭包最开始的地方：

lazy var someClosure = {
    [unowned self, weak delegate = self.delegate] in
    // 这里是闭包的函数体
}

弱引用和无主引用 (可能为nil时用弱引用，捕获的值和闭包同时销毁用无主引用unown

在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为无主引用。

相反的，在被捕获的引用可能会变为 nil 时，将闭包内的捕获定义为 弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为 nil。这使我们可以在闭包体内检查它们是否存在

 HTMLElement 类的避免循环强引用：

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        [unowned self] in  //捕获列表 将 self 捕获为无主引用而不是强引用
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

   deinit {
        print("HTMLElement \(name) is being deinitialized")
    }

}

使用捕获列表后引用关系如下图所示：

这一次，闭包以无主引用的形式捕获 self，并不会持有 HTMLElement 实例的强引用。如果将 paragraph 赋值为 nil，HTMLElement 实例将会被销毁，并能看到它的析构器打印出的消息 

paragraph = nil
// 打印  HTMLElement p is being deinitialized

参考：自动引用计数 - Swift 5.1 教程 - Swift编程

相关代码：https://download.youkuaiyun.com/download/zjh467545737/32616043