作為一門現(xiàn)代的高級編程語言，Swift代替我們進行了對象的創(chuàng)建和銷毀等相關(guān)的內(nèi)存管理明场。它使用了一個優(yōu)雅的技術(shù)屯远，叫做自動引用技術(shù)(Automatic Reference Counting)或ARC慰丛。在本篇教程中擎析，你會學(xué)習(xí)到在Swift中的ARC和內(nèi)存管理技術(shù)览妖。

隨著深入了解這一整套系統(tǒng)轧拄，你會理解堆對象的生命周期。Swift運用ARC使得在資源有限的環(huán)境下做到可預(yù)期和高效--比如在iOS系統(tǒng)下讽膏。

因為ARC是"自動"的檩电，你不需要明確的參與到對象的引用計數(shù)上面來。但是你需要考慮對象之間的引用關(guān)系府树，防止出現(xiàn)內(nèi)存泄漏俐末。這對于新人開發(fā)來說是非常重要的一點。

在本篇文章中挺尾，你可以通過學(xué)習(xí)一下的四點來提升你的Swift和ARC的相關(guān)技能:

• ARC是如何工作的鹅搪。
• 什么是循環(huán)引用以及如何打破循環(huán)應(yīng)用站绪。
• 通過一個具體的循環(huán)引用的例子遭铺，使用最新版本Xcode的可視化工具來檢測問題。
• 如何區(qū)別對待值類型和引用類型恢准。

開篇

打開Xcode魂挂，然后點擊File\New\Playground…，選擇iOS Platform,把它命名為MemoryManagement并且點擊Next馁筐。

接下來涂召，將下列的代碼添加到你的playgroud中去:

class User {
  var name: String
 
  init(name: String) {
    self.name = name
    print("User \(name) is initialized")
  }
 
  deinit {
    print("User \(name) is being deallocated")
  }
}
 
let user1 = User(name: "John")

這里定義了一個叫做User的類，然后創(chuàng)建了一個該類的示例對象敏沉。這個User類擁有一個屬性name果正、一個init的構(gòu)造方法（在開辟內(nèi)存空間之后調(diào)用）和一個deinit的析構(gòu)方法(在回收內(nèi)存空間之前調(diào)用)，print方法是用來打印當(dāng)前的生命周期事件盟迟，以便我們觀察秋泳。

你會注意到，在playgroud旁邊顯示了"User John is initialized\n",這個是在init方法中的打印輸出攒菠，但是我們會發(fā)現(xiàn)迫皱，在deinit中的print方法卻一直沒有被調(diào)用，這意味著該對象沒有一直沒有被銷毀辖众。這是因為當(dāng)前的作用域沒有閉合 -- playgroud一直沒有脫離當(dāng)前的作用域 -- 所以該對象就不會從內(nèi)存中銷毀卓起。

我們試著將user1對象包裹在do語句的作用域中，就像這樣:

do {
  let user1 = User(name: "John")
}

這里創(chuàng)建了一個作用域給初始化之后的user1對象凹炸。在該對用域結(jié)束的時候戏阅，該user1對象就會被自動銷毀。

現(xiàn)在你可以在側(cè)邊欄看到init和deinit兩個print語句的輸出了啤它。這意味著奕筐，在該對象從內(nèi)存中銷毀之前私杜，該對象在作用域結(jié)束的時候調(diào)用了析構(gòu)方法。

Swift中的對象生命周期擁有五個階段:

1. 分配 （從棧內(nèi)存或者堆內(nèi)存中分配空間）
2. 初始化(調(diào)用init構(gòu)造方法)
3. 活動 （對象的使用）
4. 析構(gòu) （調(diào)用deinit方法）
5. 回收 （從棧內(nèi)存或者堆內(nèi)存中釋放占用空間）

雖然Swift中沒有直接的hooks函數(shù)給內(nèi)存的分配和回收救欧，但是你可以使用print語句作為代理在init和deinit中監(jiān)控這些生命周期衰粹。有的時候，“分配”和“析構(gòu)”的過程是可以互換的笆怠，但是他們是生命周期中完全不同的兩個階段铝耻。

引用計數(shù)是一個當(dāng)對象不再被需要的時候自動被回收的機制。現(xiàn)在我們有一個問題：“你是如何確定一個對象在未來永遠(yuǎn)不被需要了的呢蹬刷？“瓢捉，自動引用計數(shù)會為每一個對象持有一個使用的計數(shù)，也就是我們所說的引用計數(shù)办成。

這個計數(shù)意味著有多少東西引用了該對象泡态。當(dāng)一個對象的引用計數(shù)變成了0，那么意味著沒有對象持有它迂卢，那么這個對象就可以被析構(gòu)和回收了某弦。

當(dāng)你初始化了一個User對象，ARC就從1開始了對該對象的引用計數(shù)而克。在do語句的閉包末端靶壮，user1脫離了作用域，引用計數(shù)遞減為0员萍。結(jié)果腾降，user1執(zhí)行析構(gòu)方法并且從內(nèi)存中回收。

循環(huán)引用

在大多數(shù)的情況下碎绎，ARC非常穩(wěn)定的運作著螃壤；作為一名開發(fā)者，你不需要擔(dān)心哪些對象在不確定的情況之下會發(fā)生內(nèi)存泄漏筋帖。

但是這并不是絕無可能的奸晴！內(nèi)存泄漏還是有可能發(fā)生！

那么內(nèi)存泄漏時如何發(fā)生的呢幕随？想象一下一種情況蚁滋，當(dāng)兩個對象不再需要，但是又互相引用著對方赘淮。那么這兩個對象的引用計數(shù)都不可能為0辕录，內(nèi)存回收也就永遠(yuǎn)不會發(fā)生了。

這種情況就叫做循環(huán)引用梢卸。它玩弄了ARC阻止了正常的內(nèi)存清理走诞。正如你所見，引用計數(shù)最后不會變成0蛤高，因此object1和object2永遠(yuǎn)不會被銷毀蚣旱。

為了重現(xiàn)該問題碑幅，我們將下列的代碼添加在User類的定義之下，但是再
do閉包之前：

class Phone {
  let model: String
  var owner: User?
 
  init(model: String) {
    self.model = model
    print("Phone \(model) is initialized")
  }
 
  deinit {
    print("Phone \(model) is being deallocated")
  }
}

然后改變do語句做的事情:

do { 
  let user1 = User(name: "John")
  let iPhone = Phone(model: "iPhone 6s Plus")
}

這里添加了一個新的類塞绿，叫做Phone,然后創(chuàng)建了一個Phone類的實例對象沟涨。

這個新的類非常簡單：擁有兩個屬性，一個是Model(手機型號)异吻，一個是owner(擁有者)裹赴，一個init方法和一個deinit方法。Phone可以獨立于User存在诀浪，所以owner屬性是可選的棋返。

接下來，添加下列的代碼到User類:

private(set) var phones: [Phone] = []
func add(phone: Phone) {
  phones.append(phone)
  phone.owner = self
}

這里添加了一個phones的數(shù)組來存儲當(dāng)前用戶所擁有的所有手機雷猪，該方法的setter方法是私有的睛竣，所以我們無法直接通過對phones的添加方法來添加手機，我們只能使用add方法來對用戶的手機進行添加求摇。這個方法確保了當(dāng)你添加phone的時候射沟，phone的owner被賦值。

此時月帝，我們可以在側(cè)邊看到Phone和User對象都被正確的釋放了躏惋。

但是當(dāng)我們的do語句執(zhí)行如下的操作的時候:

do { 
  let user1 = User(name: "John")
  let iPhone = Phone(model: "iPhone 6s Plus")
  user1.add(phone: iPhone)
}

在這里，你給user1添加了一臺iPhone嚷辅。這自動將user1賦值給了iPhone的owner。這時一個循環(huán)引用就產(chǎn)生了距误，并且user1和iPhone將永遠(yuǎn)不會被銷毀簸搞。

弱引用

為了打破這種循環(huán)引用，你可以指定對象的引用關(guān)系為弱引用准潭。除非有明確的說明趁俊，否者所有的引用都是強引用。弱引用和強引用相比的區(qū)別是刑然，弱引用并不會導(dǎo)致引用計數(shù)增加寺擂，并且當(dāng)弱引用指向的對象銷毀的時候自動將其置為nil。

上面的圖片中泼掠，虛線代表了弱引用怔软。值得注意的是，object1的引用計數(shù)為1是因為variable1引用了它择镇。object2的引用計數(shù)為2挡逼，是因為variable2以及object1都引用了它。雖然object2引用了object1,但是這是弱引用腻豌，意味著這不會影響對object1的引用計數(shù)家坎。

當(dāng)variable1和variable2都銷毀的時候嘱能，object1引用計數(shù)將降為0，deinit方法就會被調(diào)用虱疏。接著惹骂，它就取消了對object2的強引用，隨后object2也就被銷毀了做瞪。

現(xiàn)在我們回到playgroud,將owner屬性用weak來修飾以達(dá)到打破User-Phone的循環(huán)引用析苫，就像這樣:

class Phone {
  weak var owner: User?
  // other code...
}

現(xiàn)在user1和iPhone都會被正確的釋放掉了，我們也可以在側(cè)邊欄看到相關(guān)的打印顯示穿扳。

無主引用

其實還有另外一種不會增加引用計數(shù)的引用修飾:unowned（無主引用）衩侥。那么unowned和weak之間有什么區(qū)別呢？一個弱引用永遠(yuǎn)都是可選類型的矛物，并且當(dāng)它所指向的對象被銷毀的時候茫死，該引用會被自動置nil，這就是為什么當(dāng)你定義一個weak屬性的時候履羞，必須要使用var來通過編譯器的檢查（因為這個變量需要被改變）峦萎。

相比之下，無主引用永遠(yuǎn)都不能為可選類型忆首。如果你嘗試訪問一個無主引用所修飾的一個已經(jīng)被釋放的對象爱榔，那么你就會觸發(fā)錯誤！

是時候來一些unowned的使用練習(xí)了糙及。在do語句?之前添加一個叫做CarrierSubscription的類:

class CarrierSubscription {
  let name: String
  let countryCode: String
  let number: String
  let user: User
 
  init(name: String, countryCode: String, number: String, user: User) {
    self.name = name
    self.countryCode = countryCode
    self.number = number
    self.user = user
 
    print("CarrierSubscription \(name) is initialized")
  }
 
  deinit {
    print("CarrierSubscription \(name) is being deallocated")
  }
}

CarrierSubscription擁有四個屬性：訂單名稱（name）详幽，國家編碼(countryCode),訂單手機號碼(phone number)以及一個對User對象的引用。

接下來浸锨，在User類的name屬性之后添加如下的代碼：

var subscriptions: [CarrierSubscription] = []

這里增加了一個subscriptions的數(shù)組唇聘，這個數(shù)組保存著所有的CarrierSubscrition對象：

同樣的，在Phone類中的owner屬性之后增加如下的代碼：

var carrierSubscription: CarrierSubscription?
 
func provision(carrierSubscription: CarrierSubscription) {
  self.carrierSubscription = carrierSubscription
}
 
func decommission() {
  self.carrierSubscription = nil
}

這里增加了可選類型的CarrierSubscription屬性柱搜，以及一個provision方法和一個decommission方法迟郎，分別用來指定一個訂單和撤銷一個訂單。

接下來聪蘸，我們可以在CarrierSubscription類的init方法的打印語句之前增加下列的代碼：

user.subscriptions.append(self)

這確保了CarrierSubscription被添加到了用戶的subscriptions數(shù)組當(dāng)中去宪肖。

最后，我們的do作用域是這樣的:

do { 
  let user1 = User(name: "John")
  let iPhone = Phone(model: "iPhone 6s Plus")
  user1.add(phone: iPhone)
  let subscription1 = CarrierSubscription(name: "TelBel", countryCode: "0032", number: "31415926", user: user1)
  iPhone.provision(carrierSubscription: subscription1)
}

注意側(cè)邊欄的輸出健爬。再一次我們發(fā)現(xiàn)出現(xiàn)了循環(huán)引用：user1,iPhone和subscription1都沒有被銷毀控乾。你能看出來問題在哪里么？

user1對subscription1的引用或者subscription1對user1的引用應(yīng)當(dāng)用unowned修飾來打破循環(huán)引用』肜停現(xiàn)在的問題是阱持，哪一方需要被修飾呢？

用戶對訂單存在擁有關(guān)系魔熏，相反的衷咽，訂單對用戶是不存在擁有關(guān)系的鸽扁。此外，一個運輸訂單如果沒有目標(biāo)用戶镶骗，那么這個訂單就是沒有意義的桶现。這也是為什么在聲明user屬性的時候，我們使用不可變的let來聲明鼎姊。一個用戶可以脫離訂單存在骡和，但是訂單無法脫離用戶存在，所以訂單中所指向的用戶需要使用unowned來修飾相寇。

現(xiàn)在我們給CarrierSubscription類的user屬性通過unowned來修飾:

class CarrierSubscription {
  let name: String
  let countryCode: String
  let number: String
  unowned let user: User
  // Other code...
}

這打破了循環(huán)引用慰于，使得每一個對象都得到了正確的銷毀。

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

對象之間的循環(huán)引用發(fā)生在屬性互相強引用對方的時候唤衫。與對象類似婆赠，閉包也是一種引用類型并且會造成循環(huán)引用。閉包會捕獲它所需要進行操作的對象佳励。

舉一個例子休里，當(dāng)一個閉包被賦值給一個對象的屬性，并且該閉包也是用了該對象的引用赃承，那么就會發(fā)生循環(huán)引用妙黍。換句話說，該對象通過一個存儲屬性強引用該閉包瞧剖；而該閉包則通過捕獲self的值來保持對該對象的強引用拭嫁。

將下列的代碼添加到CarrierSubscription類的User屬性之下:

lazy var completePhoneNumber: () -> String = {
  self.countryCode + " " + self.number
}

這個閉包計算并且返回了一個完整的手機號碼。該屬性被標(biāo)記為lazy,意味著該屬性直到第一次被訪問才進行賦值運算筒繁。這樣做是必要的噩凹，因為如果你想要計算出完整的手機號碼，那么你必須首先直到它的self.countryCode（國家編碼）以及它的self.number(手機號碼)毡咏，而這兩個屬性只有在被初始化之后才是可用的，所以我們需要“惰性計算”這個特性逮刨。

接著呕缭，我們在do語句的末尾添加上如下的代碼：

print(subscription1.completePhoneNumber())

你會注意到user1和iPhone被成功的銷毀了，但是CarrierSubscription卻沒有被成功的銷毀修己，因為在該對象和閉包之間產(chǎn)生了循環(huán)引用：

Swift擁有一種簡單優(yōu)雅的方式來在閉包中打破循環(huán)引用恢总。你需要聲明一個定義閉包和捕獲對象的關(guān)系的捕獲列表。

為了說明該捕獲列表是如何工作的睬愤，我們可以先來思考一下以下的代碼：

var x = 5
var y = 5
 
let someClosure = { [x] in
  print("\(x), \(y)")
}
 
x = 6
y = 6
 
someClosure()        // Prints 5, 6
print("\(x), \(y)")  // Prints 6, 6

變量x在捕獲列表中片仿，所以當(dāng)閉包被定義的時候一份x的拷貝就會被創(chuàng)建。這也就是說尤辱，閉包只是捕獲了值而沒有捕獲引用砂豌。而與之相反的厢岂，y并沒有在捕獲列表中，所以閉包便捕獲了y的引用阳距。

使用捕獲列表來定義閉包和其中所捕獲的對象的weak或者unowned關(guān)系將變得十分有優(yōu)勢塔粒。如果CarrierSubscription一旦銷毀，那么閉包就會不存在筐摘，在這種情況之下卒茬，unowned將會十分的適合。

改變CarrierSubscription類中的completePhoneNumber閉包:

lazy var completePhoneNumber: () -> String = {
  [unowned self] in
  return self.countryCode + " " + self.number
}

這里添加了[unowned self]到閉包的捕獲列表中咖熟。這意味著圃酵，被捕獲的self由原先的強引用改變成了“無主引用”。

這樣我們就解決了循環(huán)引用馍管。

在這里我們使用的其實是一種初次引進的捕獲語法的簡寫郭赐，思考一下一列的完整寫法:

var closure = {
  [unowned newID = self] in
  // Use unowned newID here...
}

在這里newID其實是self的unowned拷貝。在閉包的作用域之外咽斧，self任然指向之前的引用堪置。然而在閉包的作用域之內(nèi)，self所指向的引用其實是一個對于self的一個新的變量张惹。

所以舀锨，在閉包中，self和completePhoneNumber的關(guān)系就是非擁有的關(guān)系了宛逗。只要你可以保證閉包中的self對象不會被銷毀坎匿，那么盡管使用unowned吧。但是如果銷毀了雷激，那么你的程序就會Crash掉替蔬。

添加下列的代碼到你的Playground:

// A class that generates WWDC Hello greetings.  See http://wwdcwall.com
class WWDCGreeting {
  let who: String
 
  init(who: String) {
    self.who = who
  }
 
  lazy var greetingMaker: () -> String = {
    [unowned self] in
    return "Hello \(self.who)."
  }
}
 
let greetingMaker: () -> String
 
do {
  let mermaid = WWDCGreeting(who: "caffinated mermaid")
  greetingMaker = mermaid.greetingMaker
}
 
greetingMaker() // TRAP!

playground會因為self而遭遇一個runtime異常，在閉包當(dāng)中屎暇，who變量任然是有效的承桥，但是其實當(dāng)mermaid超出作用域的時候，mermaid已經(jīng)被銷毀了根悼，那么這個時候訪問self就會出現(xiàn)異常凶异。這個例子可能看起來有一些做作，但是其實在日常的編程中它是很有可能發(fā)生的挤巡，比如閉包的滯后執(zhí)行剩彬，又或者是某些異步工作之后執(zhí)行。

我們把greetingMaker變成這樣：

lazy var greetingMaker: () -> String = {
  [weak self] in
  return "Hello \(self?.who)."
}

這里我們對原來的閉包進行了兩處的改動矿卑。首先我們把unowned關(guān)鍵字改成了weak,其次我們需要把訪問who屬性時候的代碼改成self?.who喉恋。

playground不再Crash了，但是你在閉包的旁邊看到了這樣的輸出:"Hello, nil.",很多時候，這樣的輸出并不是我們所期待的轻黑，這個時候guard let該出場了糊肤。

重寫之后，我們的代碼變成了這樣:

lazy var greetingMaker: () -> String = {
  [weak self] in
  guard let strongSelf = self else {
    return "No greeting available."
  }
  return "Hello \(strongSelf.who)."
}

guard語法將weak self綁定到了strongSelf這個新的變量中苔悦，如果self是一個nil那么閉包就會返回"No greeting available."轩褐，相反的，如果self不是一個nil,那么strongSelf就是一個強引用玖详，所以直到閉包結(jié)束之前都可以保證正確的運行把介。

使用Xcode8找到循環(huán)引用

現(xiàn)在你已經(jīng)明白了ARC的主要內(nèi)容，什么是循環(huán)引用以及如何打破循環(huán)引用蟋座，現(xiàn)在是時候來看一個真實的例子了拗踢。

下載這個項目,并且使用Xcode8打開。你必須使用Xcode8或者Xcode8之后的版本向臀，因為Xcode8增加了一些我們待會兒會用到的新特性巢墅。

打開運行這個項目之后你會看到這個界面：

這是一個簡單的通訊錄App。隨便點擊一個聯(lián)系人就可以看到這個人的詳細(xì)信息券膀，點擊右上角的+可以添加聯(lián)系人君纫。

讓我們來看一下代碼：

• ContactsTableViewController: 展示數(shù)據(jù)庫中的所有Contact對象。
• DetailViewController: 展示一個指定的Contact對象的詳細(xì)信息芹彬。
• NewContactViewControllerdsa: 允許用戶添加新的聯(lián)系人蓄髓。
• ContactTableViewCell: 一個自定義的Cell來展示詳細(xì)信息。
• Contact：數(shù)據(jù)庫中聯(lián)系人的模型舒帮。
• Number: 聯(lián)系人聯(lián)系電話的模型会喝。

然而這個項目有一些很大的缺陷：因為這里存在著循環(huán)引用。你的用戶也不會注意到由細(xì)小的內(nèi)存泄漏而引發(fā)的問題--而且這個問題將很難被發(fā)現(xiàn)玩郊。幸運的是肢执，Xcode8有了新的內(nèi)建工具來找到這些細(xì)小的內(nèi)存泄漏。

再次運行這個項目译红。側(cè)滑聯(lián)系人點擊刪除预茄，我們刪除三四個聯(lián)系人，這樣看起來他們?nèi)勘粍h除了侦厚，嗯反璃，沒問題...

當(dāng)App仍在運行的時候，我們來到Xcode的下方假夺，點擊Debug Memory Graph按鈕。

在Xcode中觀察新的幾種問題(警告??斋攀，錯誤?已卷，等等)：Runtime issues。他們看起來像是一個紫色的正方形淳蔼，里面有一個白色的驚嘆號侧蘸，比如下圖中選中的那樣：

在導(dǎo)航欄中選擇其中有問題的Contact對象裁眯。這樣循環(huán)引用就很明顯了：Contact和Number互相強引用對方造成了內(nèi)存泄漏。

思考一下讳癌，Contact可以脫離Number存在穿稳，但是Number卻不能脫離于Contact存在。那么你應(yīng)該怎么解決循環(huán)引用呢晌坤？使用weak或者unowned,但是應(yīng)該修飾在Number對Contact還是Contact對Number呢逢艘？

這里給你一些不錯的建議，如果你需要的話

解決方案

這里有兩種解決方案：要么骤菠，Contact對Number弱引用它改，要么，Number對Contact無主引用商乎。

蘋果官方文檔建議我們父對象應(yīng)當(dāng)對子對象強引用--不要違背這個原則央拖。這意味著，Contact應(yīng)當(dāng)強引用Number對象鹉戚，而Number應(yīng)當(dāng)對Contact保持無主引用鲜戒，這是當(dāng)前最適合的解決方案:

class Number {
  unowned var contact: Contact
  // Other code...
}

class Contact {
  var number: Number?
  // Other code...
}

再次運行工程，我們會發(fā)現(xiàn)問題被解決了抹凳！

PS：值類型和引用類型的循環(huán)

Swift的類型可以分為值類型（比如結(jié)構(gòu)體遏餐，枚舉）和引用類型（比如類）兩種。這兩者的一個主要的區(qū)別是却桶，值類型在進行賦值傳遞的時候會拷貝一份該值返回境输，而引用類型在進行賦值傳遞的時候則是返回一個該對象引用的拷貝。

那么這是不是意味著值類型永遠(yuǎn)不存在循環(huán)引用呢颖系？是的：對值類型的賦值都是拷貝操作嗅剖，沒有引用的創(chuàng)建那么也就不會存在循環(huán)引用一說了。你至少需要有兩個引用才能引發(fā)循環(huán)引用嘁扼。

回到我們的playgroud,添加下列的代碼:

struct Node { // Error
  var payload = 0
  var next: Node? = nil
}

看起來信粮，編譯器會報錯，一個結(jié)構(gòu)體（值類型）不能夠被遞歸或者使用自身的值趁啸。否則這個結(jié)構(gòu)體將會變得無窮大强缘。我們將它改變成類:

class Node {
  var payload = 0
  var next: Node? = nil
}

self的引用在類中沒有問題，所以編譯錯誤也就消失了不傅。
接著我們添加下列的代碼：

class Person {
  var name: String
  var friends: [Person] = []
  init(name: String) {
    self.name = name
    print("New person instance: \(name)")
  }
 
  deinit {
    print("Person instance \(name) is being deallocated")
  }
}
 
do {
  let ernie = Person(name: "Ernie")
  let bert = Person(name: "Bert")
 
  ernie.friends.append(bert) // Not deallocated
  bert.friends.append(ernie) // Not deallocated
}

這里是一個混合類型（值類型 + 引用類型）的循環(huán)引用的例子旅掂。

雖然friends是一個值類型的數(shù)組，但是由于friends數(shù)組的裝載了對方的引用類型的Person访娶，導(dǎo)致ernie和bert互相引用而無法釋放商虐。如果你企圖將數(shù)組標(biāo)記為unowned，那么Xcode會顯示錯誤：unowned只能用來修飾類。

為了在這里打破循環(huán)引用秘车，你將不得不創(chuàng)建一個泛型的包裝類然后使用它來講實例對象添加到數(shù)組中典勇，如果說你不知道什么是泛型蹦玫，或者不知道怎么使用它筋夏，那你可以看看這篇文章。

在定義Person類之前添加下列的代碼:

class Unowned<T: AnyObject> {
  unowned var value: T
  init (_ value: T) {
    self.value = value
  }
}

然后改變Person中friends屬性的定義：

var friends: [Unowned<Person>] = []

最后翠肘，改變do中所做的事情:

do {
  let ernie = Person(name: "Ernie")
  let bert = Person(name: "Bert")
 
  ernie.friends.append(Unowned(bert))
  bert.friends.append(Unowned(ernie))
}

OK,現(xiàn)在ernie和bert已經(jīng)被正確的釋放掉了~

friends數(shù)組已經(jīng)不再是Person對象的集合了眯亦，而是一個Unowned對象的集合伤溉，該對象封裝了Person對象。

為了訪問Person搔驼，我們可以這么做:

let firstFriend = bert.friends.first?.value // get ernie

鳴謝

本文出自raywenderlich,感謝17歲的年輕作者Maxime Defauw帶來這么好的教程谈火，希望這篇文章可以讓大家更好的了解Swift！