swift详解之九---------------自动引用计数、循环引用（这个必须理解，必须看）

拼搏现实的明天。 2022-08-04 10:56 132阅读 0赞

## 自动引用计数、循环引用（这个必须理解，必须看） ##

`注：本文详细介绍自动引用计数，以及各种循环引用问题。一网打尽！`

--------------------

### 1、 自动引用计数原理 ###

Swift 使用ARC机制来跟踪和管理你的内存，一般情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。

然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。

为了确保在使用中的实例不会被销毁 ， ARC会跟踪和计算每一个实例正在被多少属性、常量或者变量所使用，直到引用计数为 0 ，ARC就会销毁这个实例

所以，无论你将实例赋值给属性、变量或者常量的时候，他们都回创建此实例的强引用 ，会将实例保持住（引用计数+1） 只要强引用还在，实例是不允许销毁的 。  
下面来看一个例子就能轻松理解啦！

class Student{
        
    
        var name:String
        init(name:String){
            self.name = name;
            print("\(name) 实例被创建了 ")
        }
    
        deinit{
            print("\(self.name) 实例被销毁啦！！！")
        }
    
    }
    
    var st1:Student?
    var st2:Student?
    var st3:Student?
    
    //这里是一个强引用
    st1 = Student(name:"张三") //张三 实例被创建了
    st2 = st1
    st3 = st1
    //现在Student有三个强引用了 
    st1=nil;
    st2=nil
    //将这两个释放 ，这时候还有一个强引用 
    st3 = nil //张三 实例被销毁啦！！！
    //这时候所有的强引用都释放 ， 则释放这个实例

这里注释写的很清楚 ， 只有当所有的强引用释放掉 ，ARC才会释放这个实例

我们有时候会写出循环强引用的代码 。 如果两个实例互相持有对方的强引用 ，所以每个实例都会让对方一直存在着，一直不会被销毁 ，这就是所谓的循环强引用 。

### 2 、类实例之间的循环强引用 ###

这时候你可以定义类之间的关系为弱引用或者无主引用，以替代强引用。从而解决循环强引用的问题 。

下面我们先来了解一下他是怎么产生的 ：

class Animal {
        
        var name:String
        var food:Food?
    
        init(name:String){
            self.name = name
        }
    
        deinit{
            print("Animal 被销毁啦")
        }
    }
    
    
    class Food {
        
        var name:String
        var animal:Animal?
    
        init(name:String){
            self.name = name
        }
        deinit{
            print("Food 被销毁啦 ")
        }
    }

这里在Animal类中引用了Food 在Food中引用了Animal ，都是强引用

var dog:Animal? = Animal(name: "dog")
    var dogFood:Food? = Food(name: "meat")
    
    dog!.food = dogFood
    dogFood!.animal=dog
    dog = nil
    dogFood = nil

然而并不会调用析构函数 ，循环引用会一直阻止这两个实例被销毁 应用程序造成了内存泄露

*  解决循环强引用问题

Swift提供了两种办法来解决这个问题 弱引用 和 无主引用 对于生命周期中会变成nil的实例 使用弱引用 ，对于初始化赋值后。再也不会被赋值为nil的实例使用无主引用。

a 、弱引用

class Animal1 {
        
        var name:String
        var food:Food1?
    
        init(name:String){
            self.name = name
        }
    
        deinit{
            print("Animal1 被销毁啦")
        }
    }
    
    
    class Food1 {
        
        var name:String
        weak var animal:Animal1?
    
        init(name:String){
            self.name = name
        }
        deinit{
            print("Food1 被销毁啦 ")
        }
    }
    
    var dog1:Animal1? = Animal1(name: "dog")
    var dogFood1:Food1? = Food1(name: "meat")
    
    dog1!.food = dogFood1
    dogFood1!.animal=dog1
    
    dogFood1 = nil
    dog1 = nil
    
    //Animal1 被销毁啦
    //Food1 被销毁啦
    //哈哈 两个都可以被销毁啦

b 、无主引用  
无主引用也不会牢牢保持住引用的实例 ， 和弱引用不同 ，无主引用永远是有值得 。无主引用总是被定义位非可选类型 。你可以在声明的时候在前面加上关键字 `unowend` 来表示这是个无主引用  
ARC无法在实例销毁的时候将它设置位nil 因为非可选的变量永远不能被赋值为nil ，但是在实例销毁后也是无法用这个实例去访问无主引用的， 如果你强制访问 会报运行时错误

class Customer {
        
        var name:String
    
        var card:Card?
        init(name:String){
            self.name = name
        }
        deinit{
            print("Customer 被销毁")
        }
    }
    class Card {
        
        var name:String
        unowned var customer:Customer    //一个卡肯定要对应一个顾客
        init(name:String,cus:Customer){
            self.name = name
            self.customer = cus
        }
        deinit{
            print("Card 被销毁")
        }
    }
    
    
    var customer:Customer? = Customer(name: "张三")
    var card:Card? = Card(name: "招商银行金卡", cus: customer!)
    
    customer!.card = card
    customer = nil
    card = nil
    //Customer 被销毁
    //Card 被销毁
    //card!.customer //fatal error: unexpectedly found nil while unwrapping an Optional value

这个也被顺利的销毁 ，当销毁后再取访问的时候就不能访问了

前面两种解决循环引用的场景 ，第一种是两个都允许为nil , 第二个是有一个不允许为nil，但是如果两个属性都不允许位nil ，初始化完成后永远不能为nil ，这时候就需要一个类使用无主 ， 另一个使用隐式解析可选属性  
c、隐式解析可选属性

class Country{
        
        var name:String
        var city:City!
        init(name:String,cityName:String){
            self.name = name
            self.city = City(name: cityName, country: self)
        }
    
        deinit{
            print("Country 被销毁啦 ")
        }
    }
    
    
    class City{
        
    
        var name:String
        unowned var country:Country
    
        init(name:String,country:Country){
            self.name = name
            self.country=country
        }
        deinit{
            print("City 被销毁啦")
        }
    }

var country:Country? = Country(name: "China", cityName: "ShangHai")
    //这一条语句创建了两个实例
    
    var city = country!.city
    print(city.country.name) //China 
    
    city = nil
    country!.city = nil //City 被销毁啦
    country = nil //Country 被销毁啦

这里注释都写的很清楚，代码很简单 ，就不再赘述

### 3、闭包引起的循环强引用 ###

循环强引用还会发生在你将一个闭包赋值给一个类的属性 ， 闭包中又使用了这个类的实例 ，其实 这跟之前的是一样的 ，因为闭包也是引用类型的 ， 你把一个引用类型赋值给一个属性 ，然后在这个引用类型中使用这个实例 ，两个强引用一直有效.  
使用闭包捕获列表可以解决这个问题

下面看看 这个问题是怎么产生的 .

class Book{
        var name:String
        //这里定义为lazy才可以使用self 。在构造器第一阶段还不能使用self
        lazy var oldName:Void -> String = {
            return "old\(self.name)"
        }
    
        init(name:String){
            self.name = name
        }
        deinit{
            print("Book 被销毁了")
        }
    
    }
    
    var book:Book? = Book(name: "Swift书")
    print(book!.oldName()) //oldSwift书
    //oldName是一个闭包
    book = nil

这时候并没有打印出析构方法的句子。明显产生了循环引用

解决办法 ：  
定义捕获列表：捕获列表中的每一项都由一对元素组成 ，一个是weak 或者 unowned ，另一个是类的实例或者初始化变量

class Book1{
        
        var name:String
        //这里定义为lazy才可以使用self 。在构造器第一阶段还不能使用self
        lazy var oldName:Void -> String = {
            [unowned self] in
            return "old\(self.name)"
        }
    
        init(name:String){
            self.name = name
        }
        deinit{
            print("Book 被销毁了")
        }
    
    }
    
    var book1:Book1? = Book1(name: "Swift书")
    print(book1!.oldName()) //oldSwift书
    //oldName是一个闭包
    book1 = nil  //Book 被销毁了

这时会就被顺利销毁了

看下语法 ：

@lazy var someClosure: (Int, String) -> String = {
        [unowned self] (index: Int, stringToProcess: String) -> String in
        // closure body goes here
    }
    
    @lazy var someClosure: () -> String = {
        [unowned self] in
        // closure body goes here
    }

按照上述两种语法就可以了。

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

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

> 学习iOS，有他就够了，[小码哥视频，传智、黑马、各种swift书籍][swift]

[swift]: https://item.taobao.com/item.htm?spm=a230r.1.14.85.JFN9U2&id=529819836478&ns=1&abbucket=7#detail