Swift中如何避免循环引用的方法
|
内存管理中经常会遇到的一个问题便是循环引用。首先，我们来了解一下iOS是如何进行内存管理的。 和OC一样,swift也是使用自动引用计数ARC(Auto Reference Counteting)来自动管理内存的,所以我们不需要过多考虑内存管理.当某个类实例不需要用到的时候,ARC会自动释放其占用的内存. ARC ARC(Automatic Reference Counting) 是苹果的自动内存管理机制。正如其名：自动引用计数，根据引用计数来决定内存块是否应该被释放。 当一个对象被创建的时候，它的引用计数为1。在它的生命周期内，其引用计数可以增加或减少。当它的引用计数减为0的时候，其所占用内存便会被释放。其生命周期如图所示：
强引用和弱引用(Strong/Weak References) 定义一个变量的时候可以声明其strong和weak属性，默认是strong类型。
struct Example {
var strongView = UIView()
weak var weakView = UIView()
}
强引用和弱引用有什么不同呢？ 强引用会使变量的引用计数加1。如果一个对象的引用计数为2，当它再次被强引用的时候，它的引用计数会变为3。 弱引用不会增加引用计数。如果一个对象的引用计数为2，当它再次被弱引用的时候，它的引用计数仍为2。 强引用的对象能保证其被调用的时候仍在内存中，而弱引用不行。 循环引用和内存泄漏 当A引用B中的成员变量，而B又对A中的成员变量有引用的时候就会发生循环引用。
class Book {
private var pages = [Page]()
func add(_ page : Page) {
pages.append(page)
}
}
class Page {
private var book : Book
required init(book : Book) {
self.book = book
}
}
let book = Book()
let page = Page(book: book)
book.add(page)
此时，book对page有强引用，同时page对book也有强引用。这个时候便有循环引用，会导致内存泄漏。 对于这种两个变量的相互强引用导致的内存泄漏该如何解决呢？ Structs 和 Classes 正确的使用struct 和 class能避免循环引用的发生。 struct 和 class 都有成员变量，函数和协议。那么，它们之间有什么区别呢？ struct 是 值类型。 当引用或者传递 值类型 变量的时候，它会在内存中重新分配地址，copy内容到新的地址中。
struct Element {
var name : String
var number : Int
}
var firstElement = Element(name: "A",number: 1)
var secondElement = firstElement
secondElement.name = "B"
secondElement.number = 2
print(firstElement)
print(secondElement)
输出的结果为: Element(name: “A”,number: 1) Element(name: “B”,number: 2) 当引用或者传递 引用类型 变量的时候，新的变量指针指向的仍是原先的内存地址。此时原先的变量值改变的话，也会导致新变量值的变化。 比如：
class Element {
var name : String
var number : Int
required init(name : String,number : Int) {
self.name = name
self.number = number
}
}
extension Element : CustomStringConvertible {
var description : String {
return "Element(name: (name),number: (number))"
}
}
var firstElement = Element(name: "A",number: 1)
var secondElement = firstElement
secondElement.name = "B"
secondElement.number = 2
print(firstElement)
print(secondElement)
此时的输出结果为： Element(name: B,number: 2) Element(name: B,number: 2) 我们为什么在此讨论值类型和引用类型呢？ 回到之前book和pages的例子。我们用struct代替class：
struct Book {
private var pages = [Page]()
mutating func add(_ page : Page) {
pages.append(page)
}
}
struct Page {
private var book : Book
init(book : Book) {
self.book = book
}
}
var book = Book()
let page = Page(book: book)
book.add(page)
此时，便不会发生循环引用的情况。 如果仍想使用class的话，可以使用weak来避免循环引用：
class Book {
private var pages = [Page]()
func add(_ page : Page) {
pages.append(page)
}
}
class Page {
private weak var book : Book?
required init(book : Book) {
self.book = book
}
}
let book = Book()
let page = Page(book: book)
book.add(page)
Protocols Protocols在swift中使用的很广泛。class，struct 和 enum 都可以使用Protocol。但是如果使用不当的话，同样会引起循环引用。 比如：
protocol ListViewControllerDelegate {
func configure(with list : [Any])
}
class ListViewController : UIViewController {
var delegate : ListViewControllerDelegate?
override func viewDidLoad() {
super.viewDidLoad()
}
}
ListViewController 中的delegate变量是strong类型的，可以引用任何实现它protocol的变量。假如实现其protocol的变量对该 view controller 同样有强引用的话会怎么样？ 声明delegate为weak可能会避免这种情况，但是这样的话会引起编译错误，因为structs和enums不能引用weak变量。 该如何解决呢？当声明protocol的时候，我们可以指定只有class类型的变量可以代理它，这样的话就可以使用weak来修饰了。
protocol ListViewControllerDelegate : class {
func configure(with list : [Any])
}
class ListViewController : UIViewController {
weak var delegate : ListViewControllerDelegate?
override func viewDidLoad() {
super.viewDidLoad()
}
}
Closures Closures 导致循环引用的原因是：Closures对使用它们的对象有一个强引用。 比如：
class Example {
private var counter = 0
private var closure : (() -> ()) = { }
init() {
closure = {
self.counter += 1
print(self.counter)
}
}
func foo() {
closure()
}
}
此时，对象对closure有一个强引用，同时在closure的代码块中又对该对象本身有一个强引用。这样就引起了循环引用的发生。 这种情况，可以有两种方法来解决这个问题。 1.使用[unowned self]:
class Example {
private var counter = 1
private var closure : (() -> ()) = { }
init() {
closure = { [unowned self] in
self.counter += 1
print(self.counter)
}
}
func foo() {
closure()
}
}
使用[unowned self] 的时候需要注意的一点是：调用closure的时候如果对象已经被释放的话，会出现crash。 2.使用[weak self]:
class Example {
private var counter = 1
private var closure : (() -> ()) = { }
init() {
closure = { [weak self] in
self?.counter += 1
print(self?.counter ?? "")
}
}
func foo() {
closure()
}
}
[weak self] 和[unowned self] 的区别是 [weak self]处理的时候是一个可选类型。 以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。 （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |
