ARC

跟OC一樣暮屡，Swift也是采取基于引用計數(shù)的ARC內(nèi)存管理方案（針對堆空間）

Swift的ARC中有3種引用

• 強引用（strong reference）：默認(rèn)情況下踪央，引用都是強引用
• 弱引用（weak reference）：通過weak定義弱引用 净当。必須是可選類型的var取劫，因為實例銷毀后蒲每，ARC會自動將弱引用設(shè)置為nil 往湿；ARC自動給弱引用設(shè)置nil時妖异，不會觸發(fā)屬性觀察器
• 無主引用（unowned reference）：通過unowned定義無主引用 惋戏。 不會產(chǎn)生強引用，實例銷毀后仍然存儲著實例的內(nèi)存地址（類似于OC中的unsafe_unretained） 他膳；試圖在實例銷毀后訪問無主引用响逢，會產(chǎn)生運行時錯誤（野指針） Fatal error: Attempted to read an unowned reference but object 0x0 was already deallocated

weak、unowned的使用限制

weak棕孙、unowned只能用在類實例上面

Autoreleasepool

public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result

autoreleasepool { 
    let p = MJPerson(age: 20, name: "Jack") 
  p.run() 
}

循環(huán)引用（Reference Cycle）

weak舔亭、unowned 都能解決循環(huán)引用的問題诗越，unowned 要比 weak 少一些性能消耗

在生命周期中可能會變?yōu)?nil 的使用 weak

初始化賦值后再也不會變?yōu)?nil 的使用 unowned

閉包的循環(huán)引用

閉包表達(dá)式默認(rèn)會對用到的外層對象產(chǎn)生額外的強引用（對外層對象進(jìn)行了retain操作）

下面代碼會產(chǎn)生循環(huán)引用善绎，導(dǎo)致Person對象無法釋放（看不到Person的deinit被調(diào)用）

class Person { 
  var fn: (() -> ())?
  func run() { print("run") } 
  deinit { print("deinit") } 
} 

func test() {
    let p = Person()
  p.fn = { p.run() } 
} 
test()

解決：在閉包表達(dá)式的捕獲列表聲明weak或unowned引用，解決循環(huán)引用問題

p.fn = { [weak p] in p?.run() }

p.fn = { [unowned p] in p.run() }

如果想在定義閉包屬性的同時引用self芦疏，這個閉包必須是lazy的（因為在實例初始化完畢之后才能引用self）

class Person {
  lazy var fn: (() -> ()) = { [weak self] in self?.run() } 
  func run() { print("run") } 
  deinit { print("deinit") }
}
// 上邊的閉包fn內(nèi)部如果用到了實例成員（屬性肢预、方法） 編譯器會強制要求明確寫出self

如果lazy屬性是閉包調(diào)用的結(jié)果矛洞，那么不用考慮循環(huán)引用的問題（因為閉包調(diào)用后，閉包的生命周期就結(jié)束了）

class Person {
  var age: Int = 0 
  lazy var getAge: Int = { self.age }() 
  deinit { print("deinit") }
}

@escaping

非逃逸閉包烫映、逃逸閉包缚甩，一般都是當(dāng)做參數(shù)傳遞給函數(shù)

非逃逸閉包：閉包調(diào)用發(fā)生在函數(shù)結(jié)束前，閉包調(diào)用在函數(shù)作用域內(nèi)

逃逸閉包：閉包有可能在函數(shù)結(jié)束后調(diào)用窑邦，閉包調(diào)用逃離了函數(shù)的作用域擅威，需要通過@escaping聲明

class Person {
  var fn: Fn // fn是逃逸閉包 
  init(fn: @escaping Fn) {
    self.fn = fn 
  }
  func run() {
    // DispatchQueue.global().async也是一個逃逸閉包
    // 它用到了實例成員（屬性、方法）冈钦，編譯器會強制要求明確寫出self
    DispatchQueue.global().async {
      self.fn()
    }
  }
}

逃逸閉包不可以捕獲inout參數(shù)

typealias Fn = () -> () 
func other1(_ fn: Fn) { fn() } 
func other2(_ fn: @escaping Fn) { fn() }
func test(value: inout Int) -> Fn { 
  other1 { value += 1 }

  // error: 逃逸閉包不能捕獲inout參數(shù) 
  other2 { value += 1 }
  
  func plus() { value += 1 } 
  // error: 逃逸閉包不能捕獲inout參數(shù) 
  return plus
}

內(nèi)存訪問沖突（Conflicting Access to Memory）

內(nèi)存訪問沖突會在兩個訪問滿足下列條件時發(fā)生：

• 至少一個是寫入操作
• 它們訪問的是同一塊內(nèi)存
• 它們的訪問時間重疊（比如在同一個函數(shù)內(nèi)）

struct Player {
  var name: String 
  var health: Int
  var energy: Int mutating
  func shareHealth(with teammate: inout Player) { 
    balance(&teammate.health, &health) 
  }
} 
var oscar = Player(name: "Oscar", health: 10, energy: 10) 
var maria = Player(name: "Maria", health: 5, energy: 10) 
oscar.shareHealth(with: &maria) // OK 
oscar.shareHealth(with: &oscar) // Error

如果下面的條件可以滿足郊丛，就說明重疊訪問結(jié)構(gòu)體的屬性是安全的

• 你只訪問實例存儲屬性，不是計算屬性或者類屬性
• 結(jié)構(gòu)體是局部變量而非全局變量
• 結(jié)構(gòu)體要么沒有被閉包捕獲要么只被非逃逸閉包捕獲

// Ok 
func test() {
  var tulpe = (health: 10, energy: 20) 
  balance(&tulpe.health, &tulpe.energy)

  var holly = Player(name: "Holly", health: 10, energy: 10) 
  balance(&holly.health, &holly.energy)
} 
test()

指針

Swift中也有專門的指針類型瞧筛，這些都被定性為“Unsafe”（不安全的）厉熟，常見的有以下4種類型

• UnsafePointer<Pointee> 類似于 const Pointee *
• UnsafeMutablePointer<Pointee> 類似于 Pointee *
• UnsafeRawPointer 類似于 const void *
• UnsafeMutableRawPointer 類似于 void *

var age = 10 
func test1(_ ptr: UnsafeMutablePointer<Int>) { ptr.pointee += 10 } 
func test2(_ ptr: UnsafePointer<Int>) { print(ptr.pointee) } 
test1(&age) 
test2(&age) // 20 
print(age) // 20

var age = 10 
func test3(_ ptr: UnsafeMutableRawPointer) { ptr.storeBytes(of: 20, as: Int.self) } 
func test4(_ ptr: UnsafeRawPointer) { print(ptr.load(as: Int.self)) } 
test3(&age) 
test4(&age) // 20 
print(age) // 20

指針的應(yīng)用示例

var arr = NSArray(objects: 11, 22, 33, 44) 
arr.enumerateObjects { (obj, idx, stop) in 
    print(idx, obj) 
    if idx == 2 { 
    // 下標(biāo)為2就停止遍歷 
    stop.pointee = true 
  } 
}

var arr = NSArray(objects: 11, 22, 33, 44) 
for (idx, obj) in arr.enumerated() { 
  print(idx, obj) 
  if idx == 2 { break } 
}

獲得指向某個變量的指針

var age = 11 
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 } 
var ptr2 = withUnsafePointer(to: &age) { $0 } 
ptr1.pointee = 22 
print(ptr2.pointee) // 22 
print(age) // 22

var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) } 
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) } 
ptr3.storeBytes(of: 33, as: Int.self) 
print(ptr4.load(as: Int.self)) // 33 
print(age) // 33

獲得指向堆空間實例的指針

class Person {} 
var person = Person() 
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0) } 
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self)) 
print(heapPtr!)

創(chuàng)建指針

var ptr = UnsafeRawPointer(bitPattern: 0x100001234)// 創(chuàng)建 


var ptr = malloc(16) 
// 存 
ptr?.storeBytes(of: 11, as: Int.self) 
ptr?.storeBytes(of: 22, toByteOffset: 8, as: Int.self) 
// 取 
print((ptr?.load(as: Int.self))!) // 11 
print((ptr?.load(fromByteOffset: 8, as: Int.self))!) // 22
// 銷毀 
free(ptr)

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) 
ptr.storeBytes(of: 11, as: Int.self) 
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self) 
print(ptr.load(as: Int.self)) // 11 
print(ptr.advanced(by: 8).load(as: Int.self)) // 22 
ptr.deallocate()


var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3) 
ptr.initialize(to: 11) 
ptr.successor().initialize(to: 22) 
ptr.successor().successor().initialize(to: 33)
print(ptr.pointee) // 11 
print((ptr + 1).pointee) // 22 
print((ptr + 2).pointee) // 33
print(ptr[0]) // 11 
print(ptr[1]) // 22 
print(ptr[2]) // 33
ptr.deinitialize(count: 3) 
ptr.deallocate()



class Person {
  var age: Int 
  var name: String 
  init(age: Int, name: String) {
    self.age = age
    self.name = name
  } 
  deinit { print(name, "deinit") }
}

var ptr = UnsafeMutablePointer<Person>.allocate(capacity: 3) 
ptr.initialize(to: Person(age: 10, name: "Jack")) 
(ptr + 1).initialize(to: Person(age: 11, name: "Rose")) 
(ptr + 2).initialize(to: Person(age: 12, name: "Kate")) 
// Jack deinit 
// Rose deinit 
// Kate deinit 
ptr.deinitialize(count: 3) 
ptr.deallocate()

指針之間的轉(zhuǎn)換

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ptr.assumingMemoryBound(to: Int.self).pointee = 11 
(ptr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0

print(unsafeBitCast(ptr, to: UnsafePointer<Int>.self).pointee) // 11 
print(unsafeBitCast(ptr + 8, to: UnsafePointer<Double>.self).pointee) // 22.0

ptr.deallocate()

// unsafeBitCast是忽略數(shù)據(jù)類型的強制轉(zhuǎn)換，不會因為數(shù)據(jù)類型的變化而改變原來的內(nèi)存數(shù)據(jù)  
// 類似于C++中的reinterpret_cast

class Person {} 
var person = Person() 
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self) 
print(ptr)