Swift 强引用的解决方案(unowned 、 weak 、隐式解析可选属性)

Swift 提供了两种方法来解决使用类的属性时的循环强引用的问题,他们是 弱引用(weak reference)和无主引用(unowned reference)。

简单的说,当其中一个实例有更短的生命周期的时候,使用弱引用。
而当一个实例有相同或者更长的生命周期的时候,使用无主引用

一:弱引用

弱引用不会保持所引用的实例,所以即使引用存在,实例也可以被销毁。 因此 ARC 在引用的实例被销毁后,会自动为他赋值 nil 。因为弱引用允许他们的值在程序允许时被赋值为 nil,所以他们都被定义为可选类型。

    class Person {
        let name: String
        init(name: String) { self.name = name }
        var apartment: Apartment?
        deinit { print("\(name) 被销毁了") }
    }
    class Apartment {
        let name: String
        init(name: String) { self.name = name }
        weak var person : Person?
        deinit {
            print("\(name) 被销毁了")
        }
        
    }

    var yunfei : Person? = Person(name: "云飞")
    var zhalongkou : Apartment = Apartment(name: "闸弄口")
    yunfei?.apartment = zhalongkou
    zhalongkou?.person = yunfei
        
    yunfei = nil
    zhalongkou = nil

yunfei 持有对 zhalongkou的强引用,zhalongkou 持有对 yunfei 的弱引用。
这个时候断开 yunfei 所保持的强引用,Person 类就没有强引用指向它了。所以它就销毁了

二:无主引用

无主引用也不会一直保持引用的实例,但是无主引用用来其他实例有相同或者更长的生命周期。
(无主引用应该一直指向一个未销毁的实例)

    class Customer {
        let name: String
        var card: CreditCard?
        init(name: String) {
            self.name = name
        }
        deinit { print("\(name) 被销毁了") }
    }
    class CreditCard {
        let number: UInt64
        unowned let customer: Customer
        init(number: UInt64, customer: Customer) {
            self.number = number
            self.customer = customer
        }
        deinit { print("信用卡 #\(number) 被销毁了") }
    }

        var yunfei : Customer? = Customer(name: "云飞")
        yunfei?.card = CreditCard(number: 13141516, customer: yunfei!)
        
        yunfei = nil        
        yunfei = nil

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

现在 yunfei 持有对 Customer类型的强引用。ICBC_card 持有对Customer 的无主引用。这个时候把 yunfei 置空,没有指向 Customer 的强引用了。所以该实例被销毁了,同时没有指CreditCard的强引用,所以它的实例也被销毁了

三:隐式解析可选属性

    class Country {
     let name: String
     var capitalCity: 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
     init(name: String, country: Country) {
         self.name = name
         self.country = country
     }
    }

Country 的构造函数调用了 City 的构造函数。然而,只有 Country 的实例完全初始化后, Country 的构造函数 才能把 self 传给 City 的构造函数。
为了满足这种需求,通过在类型结尾处加上感叹号City!的方式,将CountrycapitalCity 属性声明为隐 式解析可选类型的属性。这意味着像其他可选类型一样,capitalCity属性的默认值为 nil,但是不需要展开它 的值就能访问它。
由于 capitalCity默认值为 nil,一旦Country的实例在构造函数中给 name 属性赋值后,整个初始化过程就完 成了。这意味着一旦name 属性被赋值后, Country 的构造函数就能引用并传递隐式的selfCountry 的构造函 数在赋值 capitalCity 时,就能将 self作为参数传递给 City 的构造函数。
以上的意义在于你可以通过一条语句同时创建 CountryCity 的实例,而不产生循环强引用,并且属性能被直接访问,而不需要通过感叹号来展开它的可选值。

以上就是解决 Swift 实例间强引用的几种方案了。

推荐阅读更多精彩内容