Swift 自动引用计数(十四)

自动引用计数

1.工作机制

当创建一个类的实例，ARC就会分配一块内存来存储实例的信息，内存中包含实例的类型信息以及这个实例所有相关属性的值。当实例不再使用，ARC释放实例所占用的内存，并让释放的内存另作他用，确保不再使用的内存不会一直占用内存
当ARC回收了正在使用的实例，该实例的方法和属性将不能再被访问和操作，如果此时尝试使用，应用将会崩溃。为了确保使用中的实例不会被错误的销毁，ARC会跟踪和计算每一个实例正在被多少属性，常量和变量引用，将实例进行赋值的时候，都会对此实例创建强引用，只要强引用还在，实例是不允许被销毁的

2.测试

class Person {
    let name: String
    init(name: String) {
        self.name = name
        println("\(name) is being initialized")
    }
    deinit {
        println("\(name) is being deinitialized")
    }
}

// 变量被定义为可选类型(Person?)，他们的值会自动赋值为nil，暂时还不会引用到Person实例
var reference1: Person?
var reference2: Person?
var reference3: Person?

// 当调用Person类的构造函数，Person类的新实例赋值给reference1变量，之间建立了一个强引用，保证Person实例不会被ARC销毁
reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized"

// 当赋值给其他两个变量，该实例又多出两个强引用
reference2 = reference1
reference3 = reference1


// 通过给变量赋nil，断开强引用，现在还有一个，Person类还不会被销毁
reference1 = nil
reference2 = nil

// 最后一个强引用被断开，析构函数执行，Person实例被销毁
reference3 = nil
// prints "John Appleseed is being deinitialized"

3.类实例之间的循环强引用

当两个类相互保持对方的强引用，让对方不被销毁，这就是循环强引用，可以通过定义类之间的关系为弱引用或者无主引用，代替强引用来解决循环强引用的问题

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) is being deinitialized") }
}
 
class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

// 定义两个可选的变量，设定为以上两个类的实例，初始化为nil
var john: Person?
var number73: Apartment?

// 赋值之后，john有一个指向Person实例的强引用，number73有一个指向Apartment实例的强引用
john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

// 感叹号用来访问可选变量john和number73中的实例，这样实例的属性才能被赋值
john!.apartment = number73
number73!.tenant = john

// 当两个实例关联在一起，现在Person实例有一个指向Apartment实例的强引用，Apartment实例也有一个指向Person的强引用，断开john和number73变量所持有的强引用时，引用计数并不会降为0，实例也不会被ARC销毁，此时已经造成了内存泄露，Person和Apartment实例之间的强引用关系保留了下来并且不会被断开。
john = nil
number73 = nil

4.解决实例间的循环强引用

4.1弱引用

弱引用不会牢牢保持住引用的实例，不会阻止ARC销毁被引用的实例，防止了引用变为循环强引用，在属性前面加 weak 关键字标明这是个弱引用
弱引用必须声明为变量，表示其值在运行时会被修改，不能声明为常量，因为弱引用可以没有值，必须将弱引用声明为可选类型，可选类型是Swift中推荐使用的用来声明可能没有值的类型

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) is being deinitialized") }
}

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    weak var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

var john: Person?
var number73: Apartment?
 
john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)
 
john!.apartment = number73
number73!.tenant = john

// Person实例保存着对Apartment实例的强引用，但是Apartment只是对Person实例的弱引用，当断开john变量所保持的强引用时，再没有指向Person实例的强引用了
john = nil
// prints "John Appleseed is being deinitialized"

// 此时也没有指向Apartment实例的强引用，该实例也会被销毁
number73 = nil
// prints "Apartment #73 is being deinitialized"

4.2无主引用

和弱引用不同，无主引用是永远都有值的，不能声明为可选类型，在前面加 unowned 关键字表示这是一个无主引用

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { println("\(name) is being deinitialized") }
}
 
class CreditCard {
    let number: Int
    unowned let customer: Customer
    init(number: Int, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { println("Card #\(number) is being deinitialized") }
}

var john: Customer?

// Customer实例拥有对CreditCard实例的强引用，而CreditCard实例拥有对Customer实例的无主引用，当断开john变量持有的强引用，就没有指向Customer实例的强引用了
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

john = nil
// prints "John Appleseed is being deinitialized"
// prints "Card #1234567890123456 is being deinitialized"

4.3无主引用以及显式展开的可选属性

class Country {
    let name: String
    let 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
    }
}

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

5.闭包引起的循环强引用

将一个闭包赋值给类实例的某个属性，并且这个闭包中又实用了该实例也有可能会发生循环强引用。这个闭包可能访问了实例的某个属性，或者调用了实例的某个方法，导致了闭包捕获self，从而产生了循环强引用。因为闭包和类相似都是引用类型，当把一个闭包赋值给某个属性，也把一个引用赋值给了这个闭包

class HTMLElement {
    
    let name: String
    let text: String?
    
    @lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    
    deinit {
        println("\(name) is being deinitialized")
    }
    
}

// 实例asHTML属性持有闭包的强引用，但闭包体内使用了self，因此该闭包占用了self，意味着闭包反过来持有了HTMLElement实例的强引用，这样对象就产生了循环强引用
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
println(paragraph!.asHTML())
// prints "<p>hello, world</p>"

paragraph = nil

6.解决闭包引起的循环强引用

在定义闭包时同时定义占有列表作为闭包的一部分，占有列表定义了闭包体内占有一个或多个引用类型的规则

6.1定义占有列表

占有列表中的每个元素都有weak或unowner关键字和实例的引用成对组成

// 占有列表放置在闭包参数列表和返回类型之前
@lazy var someClosure: (Int, String) -> String = {
    [unowned self] (index: Int, stringToProcess: String) -> String in
    // closure body goes here
}
// 如果闭包没有指定参数列表或者返回类型，通过上下文判断，占有列表放在闭包开始的地方，跟着是关键字 in
@lazy var someClosure: () -> String = {
    [unowned self] in
    // closure body goes here
}

6.2弱引用和无主引用

class HTMLElement {
    
    let name: String
    let text: String?
    
    @lazy var asHTML: () -> String = {
        [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    
    deinit {
        println("\(name) is being deinitialized")
    }
    
}


var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
println(paragraph!.asHTML())
// prints "<p>hello, world</p>"


paragraph = nil
// prints "p is being deinitialized"