循环引用和ARC机制

作者: 张义飞 | 来源:发表于2017-03-18 14:46 被阅读0次

循环引用和ARC机制
iOS基础 Block解决循环引用
第十六章自动引用计数
iOS-底层原理(11)-block-循环引用详解
11 block-循环引用详解
Swift：基础（二十七）自动引用计数
Swift 内存管理
Block 04 - 循环引用
delegate 和 block 避免循环引用
iOS 内存管理、查找循环引用

自动引用计数

swift使用自动引用计数来管理内存的使用情况，开发者不需要去管理对象是如何释放的，当该对象没有被引用时，系统会自动将它们从堆中销毁.

注意
引用计数只使用与类的实例，对于枚举和结构体这些值类型的实例不适用，不会通过引用存储和传递。

ARC是如何工作的哪

每次创建一个实例，ARC会在堆上为该对象进行分配内存，而该对象的引用则会会被分配到栈上。
当不在需要实施时，ARC会释放该实例对象，确保该对象不会占用内存空间。
如果访问了已经被ARC释放的实例的属性会引起程序的崩溃，为了确保实例需要时不会被释放，ARC会追踪当前引用的实例对象的属性，不管是常量或者变量都将强引用当前的实例对象，只要有至少一个活动引用，ARC就不会释放实例。

通过列子来看ARC是如何工作的

我们创建一个类，该类有一个存储属性name

class Person {
    let name: String
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("Person被释放了")
    }
}

之所以使用optional,是为了使用值nil进行初始化，并且当前不在引用当前Person实例

var p1: Person? = Person(name: "Bill")
var p2: Person? = p1
var p3: Person? = p1

我们将p1,p2置为nil发现实例并没有被销毁

QQ20170318-2@2x.png

p1 = nil
p2  = nil

将三个都置为nil发现实例被销毁了

p1 = nil
p2  = nil
p3 = nil

QQ20170318-3@2x.png

类之间强引用造成内存泄漏问题

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 }
    var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

创建两个引用

var john: Person?
var unit4A: Apartment?

将引用指向实例对象

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

QQ20170318-4@2x.png

该john变量现在具有对新Person实例的强引用，并且该unit4A变量具有对新Apartment实例的强引用：
将两个实例进行关联

![QQ20170318-6@2x.png](https://img.haomeiwen.com/i1767327/48e66895af37d61d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

john!.apartment = unit4A
unit4A!.tenant = john

试图释放对象引用

![Uploading QQ20170318-7@2x_361139.png . . .]

john = nil
unit4A = nil

Person实例和Apartment实例之间的强引用保留，不能被破坏。

如何解决循环引用问题

swift提供了两种方法去解决循环问题，weak,unowned。如何判断是使用哪种方案哪。当两个对象的生命周期不同时可以先把生命周期短的对象释放掉，使用weak。相反与一个实例具有相同的生命周期或者更长应该使用unowned.

weak var unit4A: Apartment?

打破引用

QQ20170318-7@2x.png

john = nil

对Apartment实例唯一的剩余强引用来自unit4A变量。如果你打破这个强引用，没有更多的强引用的Apartment实例：

unit4A = nil

QQ20170318-8@2x.png

大家想一下我们刚才释放对象的先后顺序，被设为weak的对象先被释放，这就是刚才所说的两个实例生命周期不同时可以这样使用。我们反过来试试，先释放Apartment实例。

unit4A = nil
john = nil

Apartment实例还是在Person实例释放后释放掉的。大家思考一下。

大家注意弱引用有时用于简单的缓存机制，他只有等到内存压力触发垃圾回收时才被释放。而当没有引用指向该对象实例的时候，该对象实例会被内存自动释放。

无主引用

在Person和Apartment实施例表示这样一种情况，其中两个属性，这两者都允许是nil这时使用weak比较好。如果其中一个属性不能为nil时使用无主引用比较好
下面的例子中定义了两个类别，Country并且City，其中每个存储其他类作为属性的一个实例。在这个数据模型中，每个国家必须总是有一个首都，每个城市必须总是属于一个国家。为了表示这一点，Country类有一个capitalCity属性，并且City该类有一个country属性：

这样初始化就出现问题了，因为他们两个互相需要，无法初始化。我们使用依赖注入方式。在counttry初始化函数里对city也进行初始化，这样country里的countrycity也便有了值。

class Country {
    let name: String
    var capitalCity: City!
    init(name: String, capitalName: String) {
        self.name = name
        self.capitalCity = City(name: capitalName, country: self)
    }
    deinit {
        print("Country被释放了")
    }
}

class City {
    let name: String
    let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
    
    deinit {
        print("City被释放了")
    }
}

这个时候我们初始化一个country对象，此时并没有city对象被显示初始化，它在country对象里被初始化的。

var country: Country? = Country(name: "Canada", capitalName: "Ottawa")
print("\(country?.name)'s capital city is called \(country?.capitalCity.name)")

我们释放country对象，country对象并没有被释放掉。我们思考一下为什么，country对象里有一个city的引用，而city对象初始化时有引用了country对象。所以造成了循环引用问题，这时我们想想如何使用我们所学的解决循环引用问题去解决哪。不能使用weak，weak对象是optioal的现在两个对象引用都是不能为空的。那我们使用无主引用。那到底谁应该被声明称unowned的哪。试试看。city无主引用country，为什么？因为现有的国家后有的城市，city的初始化在country里。因为city强引用这country实例的引用才造成的country实例对象不能被释放，所以city应该unowned country实例对象。
使用unowned我们看到两个对象被同时释放掉了，也就是一开始说的两个实例具有相同的生命周期。