自动引用计数(ARC)

Swift中ARC的原理同OC中是相同的，简单来讲就是当实例不再被使用（引用计数为0）时，实例会被释放。
为确保实例不会被提前销毁而引起程序崩溃，ARC会跟踪和计算每一个实例被多少属性、常量、和变量引用，无论是将实例赋值给属性、常量还是变量，它们都会对实例保持强引用，只要强引用还在，实例就不会被销毁。

类实例之间的循环引用

当两个实例互相强引用对方的时候，就会造成循环引用，任何一方都无法被正常释放。
举个例子:

class Person {
   let name: String
   init(name: String) { self.name = name }
   var apartment: Apartment?
   deinit{print"\(name) is being deinitialized"}
}
class Apartment {
   let number: Int
   init(number: Int) { self.number = number }
   var tenant: Person?
  deinit{print"apartment is being deinitialized"}
}
var john: Person?
var number73: Apartment?
john = Person(name: "John Appleseed

number73 = Apartment(number: 73)
john.apartment = number73
number73.tenant = john
john = nil
number73 = nil

运行可以看出，由于john有一个只想Person的强引用，而number73有一个指向Apartment的强引用，所以都无法释放。
强引用关系如图所示：

实例之间强引用的解决方法

• 用weak修饰，适用于引用可以为nil的一方。如上面例子中，apartment可以为空，因此可以用weak修饰tenant:

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

• 用unowned修饰，适用于一方的引用不能为 nil的情形。如下面的例子，没个信用卡必定会有一个主人，因此信用卡类中的customer用unowned来修饰以解决循环引用

   class Customer {
       let name: String
       var card: CreditCard?
       init(name: String) {
           self.name = name
       }
   }

   class CreditCard {
       let number: UInt64
       unowned let customer: Customer
       init(number: UInt64, customer: Customer) {
           self.number = number
           self.customer = customer
       }
   }

• unowned和隐式解包的可选属性结合使用，适用于双方都不能为nil都有值的情况。如下面的例子，每个国家都会有城市，每个城市也都会属于某个国家：

 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
     }
 }

闭包引起的循环引用

循环引用还会发生在当你将一个闭包赋值给实例的某个属性，而且闭包中又使用了这个实例（类使用OCblock中使用了self）。
产生的原因和类相似，因为闭包同类一样都是引用类型。

class HTMLElement{
    let name: String
    let text: String?
    
    lazy var asHTML: Void -> 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{
        print("\(name) is being deinitialized")
    }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello,world")
print(paragraph!.asHTML())
paragraph = nil

在这个例子中asHTML属性持有了闭包的强引用，而闭包中又使用了self引用了self.name和self.text，因此闭包捕获了self，这以为了闭包反过来持有了实例的强引用。这样就产生了循环引用

解决闭包引起的循环引用

解决方法是定义闭包的捕获列表，在捕获列表中对对象进行weak或者unowned修饰。

• 如果闭包有参数列表和返回类型，把捕获列表放在它们前面：

lazy var someClosure: (Int, String) -> String = {
    [unowned self, weak someInstance] (index: Int, stringToProcess: String) -> String in
    // closure body goes here
}  

• 如果闭包没有指明参数列表和返回类型，即它们会通过上下文推断，那么可以把捕获列表和关键字in写在闭包最开始的地方：

lazy var someClosure: Void -> String = {
    [unowned self, weak someInstance] in
    // closure body goes here
}  

对于上面的例子，我们可以这样修改:

class HTMLElement{
    let name: String
    let text: String?
    
    lazy var asHTML: Void -> 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{
        print("\(name) is being deinitialized")
    }
}