Swift内存管理（ARC）之循环引用

概述Swift中是采用自动引用计数(ARC，AutomaticReferenceCounting)机制来对内存进行管理的。 一、简述ARC如何工作： 每当你每创建一个新的对象，它便会分配一块内存来存储该对象的相关信息。当你不再需要这个对象的时候，它就会自动释放这个对象，避免它再占用内存空间。当然，如果该对象只要至少存在一个引用就不会被释放。另外，你如果访问了一个已经被释放的对象，则很有可能会出现崩溃（

Swift中是采用自动引用计数(ARC，automaticReferenceCounting)机制来对内存进行管理的。

一、简述ARC如何工作：

每当你每创建一个新的对象，它便会分配一块内存来存储该对象的相关信息。当你不再需要这个对象的时候，它就会自动释放这个对象，避免它再占用内存空间。当然，如果该对象只要至少存在一个引用就不会被释放。另外，你如果访问了一个已经被释放的对象，则很有可能会出现崩溃（野指针）。
拿《The Swift Programming Language》里面的例子来套一下：

//创建一个Cat类，自带常量name属性class Cat {    let name: String    init(name: String) {    //初始化name属性        self.name = name;        print("\(name) 对象已经被初始化")    }    deinit {        print("\(name) 对象释放成功！")    }}

接下来定义三个变量类型为:Cat?用来对一个新的Cat对象建立多个引用。因为变量是一个可选类型（是Cat?而不是Cat）， 他们会自动给变量初始化为nil，所有当前它不需要引用一个Cat对象。

var cat1: Cat?var cat2: Cat?var cat3: Cat?

创建一个新的Cat对象，并对之前定义的三个变量进行赋值 *** 作：

cat1 = Cat(name: "jack")//输出：jack 对象已经被初始化

当你调用Cat类构造器，它会输出：”jack 对象已经被初始化”。这就代表已经完成了对象初始化 *** 作。接下来，一个新的Cat对象被赋值给了 cat1变量，从而建立了cat1对新Cat实例对象的强引用。因此，它存在了至少一个强引用。这个新的Cat对象就不会被释放。
如果你把同一个Cat实例对象赋值给另外两个变量，它则又多建立了两个强引用。

//通过赋值对Cat实例对象建立强引用cat2 = cat1cat3 = cat1

此时这个Cat实例对象已经有三个强引用了。
如果你用把其中两个变量赋值为nil的方式来打破这些强引用，对象是不会被释放的。因为它还存在一个强引用。

//通过把置nil来打破cat1,cat2对Cat实例对象的强引用cat1 = nilcat2 = nil

只有直到对象所有的引用被打破，ARC才会释放该对象

//打破最后一个强引用cat3 = nil//输出：jack 对象释放成功！

当最后一个强引用被打破后，这个Cat对象被成功释放，输出：jack 对象释放成功！

二、循环引用

1、什么是循环引用？
简单的来说就是两个对象互相持有对方，使对方处于活跃状态不被释放，从而导致了循环引用。套个例子：

//创建一个Cat类，拥有一个String类型的name属性与一个可选类型的dog属性。class Cat {    let name: String    init(name: String) {        self.name = name;        print("\(name) 对象已经被初始化")    }    var dog: Dog?    deinit {        print("\(name) 对象释放成功！")    }}//创建一个Dog类，拥有一个String类型的type属性与一个可选类型的jack属性。class Dog {    let type: String    init(type: String) {        self.type = type        print("\(type) 对象已经被初始化")    }    var cat: Cat?    deinit {        print("\(type) 对象释放成功")    }}

定义两个变量并初始化

var jack: Cat?var tom: Dog?jack = Cat(name: "jack")//print:jack 对象已经被初始化tom = Dog(type: "red")//print:red 对象已经被初始化

建立强引用

jack!@H_403_160@.dog = tomtom!@H_403_160@.cat = jack

通过把对象置nil打破强引用

jack = niltom = nil

这个地方Cat对象和Dog对象都不会被释放，因为他们两个之间还存在强引用。

解决循环引用办法
Swift提供了两种方法来解决循环引用问题：

（1）弱引用（weak）

（2）无主引用（uNowned）

声明变量或属性时，在前面加上”weak”关键词表示它是一个弱引用。如果确定访问属性或函数的时候该对象不会被释放，也可以用无主引用（uNowned）来取代。uNowned跟Objective-C中的unsafe_unretained类似。它与weak的区别在于weak在引用的对象被释放后，会自动置nil。所以它必须声明成可选类型（？）。而uNowned在引用对象被释放后不会自动置nil(因为非可选类型的变量不能被设置成nil)，而是保留对原有对象的无效引用，一旦对象被释放，再访问该对象的属性或函数就会造成崩溃。官方建议是当你在可以确定访问属性或函数所属对象不会被释放时，使用uNowned。否则，还是使用weak吧！

解决上面代码的循环引用问题，可做如下修改：

class Dog {    let type: String    init(type: String) {        self.type = type        print("\(type) 对象已经被初始化")    }    weak var jack: Cat    deinit {        print("\(type) 对象释放成功")    }}

jack = niltom = nil

2、常见的循环引用问题：

（1）delegate
在项目中我们经常会用到代理模式，在Objective-C中我们一般在delegate前面加上weak关键词，表示它是一个弱引用。从而达到打破循环引用的效果。

//在前面加上@objc是指定这里的代码属于Objective-C的代码，因为Swift中协议可以用于class、struct、enum。对于基本数据类型，它不是对象，没有引用计数这个概念，因此无法使用weak关键词。 Objective-C中的协议只适用于类，所以这里需要加上@objc。@objc protocol AClassDelegate {    func wash()}class A {    weak var delegate: AClassDelegate!    func cry() {    }    func play() {        delegate.wash()    }}class B: AClassDelegate {    func Feed() {        let nurse = A()        nurse.delegate = self        nurse.cry()    }    @objc func wash() {        print("begin wash and sleep")    }}

（2）Block(闭包)中的循环引用
Block(闭包)的循环引用在于它会持有所有引用的元素。比如我们在Block(闭包)中访问了self，那么它就持有了self。这样一来就形成了一个环：self持有Block(闭包)，Block(闭包)持有self。下面我们举个栗子加以说明：类A中有个闭包，我们在闭包中访问了self的name属性。

class A {    let name: String    lazy var wash: VoID ->VoID = {        var name = self.name + " nurse"        print("wash room is \(name)")    }    init(name: String) {        self.name = name        print("\(self.name) 创建了")    }    deinit {        print("\(self.name) 释放了")    }}class B {    func play() {        var nurse: A?        nurse = A(name: "jack")        nurse?.wash()    }}var baby: B?baby = B()baby?.play()输出结果：jack 创建了wash room is jack nurse

因为wash是self的一个属性，所以wash被self持有。这个时候我们又在闭包中访问了self的name属性，所以它又在闭包中持有了self。这样便导致了循环引用。为了解决闭包中的循环引用问题，Swift中提供了一个叫”闭包捕获列表”的解决方案。

定义一个捕获列表

捕获列表中的每一项都是一个用weak或 uNowned关键字与一个实例对象的引用（如self）或者是一个用初始化值的变量（如delegate = self.delegate!）搭配成对，配对之间用逗号隔开，最后用方括号括起来。如下所示：

lazy var someClosure:(Int,String) -> String = {    [uNowned self,weak delegate = self.delegate!] (index: Int,stringtoprocess: String) -> String in}

如果闭包中没有指定参数列表或者返回类型，可直接把捕获列表放置在闭包开始的地方（花括号后面）然后紧跟着是”in”关键词，示例代码如下：

lazy var someClosure:VoID -> String = {    @H_403_160@[uNowned self,weak delegate = self.delegate!@H_403_160@] in }

如果捕获的引用总是不会为nil，那么它应该作为一个无主引用(uNowned)被捕获，这样会比弱引用(weak)要好。

解决Block(闭包)中的循环引用，ClassA中的Block(闭包)代码可做以下修改：

lazy var wash:VoID ->VoID = { [weak self] in//这个地方使用self!.name而不是self.name。是因为weak修饰，self有可能为nil，如果是uNowned修饰，这个地方应该是self.name。因为uNowned修饰的self永远不可能为空。        var name = self!.name + " nurse"        print("wash room is \(name)")    } 输出结果：jack 创建了wash room is jack nursejack 释放了

参考资料及文章 《The Swift Programming Language》 内存管理，WEAK 和 UNOWNED Swift学习笔记-内存管理 总结

以上是内存溢出为你收集整理的Swift内存管理（ARC）之循环引用全部内容，希望文章能够帮你解决Swift内存管理（ARC）之循环引用所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。