自动引用计数

Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存

自动引用计数的工作机制

每次创建新的实例，ARC会开辟一块内存来储存实例信息，当实例对象不在使用了，ARC会释放所占用的内存。如果对象引用计数不为0，ARC 都不会销毁这个实例。

class Person {
   
   let mName:String
   init(name:String) {
       mName = name
   }
   
   // 析构
   deinit {
       let count = CFGetRetainCount(self)
       print(count)
   }
   
   // getcount
   func getRefCount() -> Int {
       
       return CFGetRetainCount(self)
   }
}

var a1 = Person(name:"zsn1")
var a2:Person? = a1

a1.getRefCount
print(a1.getRefCount()) // 5

a2 = nil
print(a1.getRefCount()) // 4

循环引用

• 类实例之间的循环强引用

  当两个类实例互相持有对方的强引用，引用计数不会为0，造成强引用。
  ```swift
  // 持有人
  class Person {

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

  }
  // 类型
  class Producer {

    let materials: String
    let name:Apartment
    
    init(materials: String) { self.materials = materials }
    deinit { print("\(materials) is being deinitialized") }
  

  }

  // 公寓
  class Apartment {

    let unit: String
    // 弱引用持有人
    weak var tenant: Person?
    
    // 无主引用 unowned(unsafe)
    // 使用无主引用，你必须确保引用始终指向一个未销毁的实例。
    unowned let producer:Producer
    
    init(unit: String,producer:String) { self.unit = unit , self.producer = producer}
    deinit { print("Apartment \(unit) is being deinitialized") }
  

  }

• 闭包的循环强引用

  class HTMLElement {
  
      let name: String
      let text: String?
      
      lazy var asHTML: () -> String = { [unowned self] in 
          //定义弱引用或无主引用捕获列表
          // weak delegate = self.delegate, weak self                                     
          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
      }
  }
  //
  HTMLElement(name:"div").asHTML()