我發現自己寫代碼的時候經常擔心強引用循環（retain cycles）的出現。我覺得這個和其他問題一樣比較常見。不知道你是什么情況，我反正總是聽見"我什么時候要用關鍵詞weak？'unowned'這坨東西到底是啥玩意兒？"這類聲音。我們發現的問題是我們知道在swift代碼中要去用strong，weak和unowned說明符來避免強引用循環，但是我們不大了解具體用哪一個。好在我知道它們是啥，還知道啥時候去用他們！希望這篇文章能教會你知道什么時候，并且在哪里用這3個說明符。

咱們開始吧

ARC

ARC是自動內存管理Apple版本的一個編譯時特性（compile time feature）。全稱是Automatic Reference Counting。意思是對于一個對象來說，只有在沒有任何強引用指向它時，該對象占用的內存才會被回收。

STRONG - 強引用

從什么是強引用說起。它本質上是一個普通的引用（指針或者其他有相同意思的東西），但是它特殊在能夠通過將該引用指向對象（object）的保留計數（retain count）增加1來保護這個對象不被ARC回收。實質上，哪怕任何一個東西的一個強引用指向了這個對象，這個對象就不會被回收。記住這點，待會兒講強引用循環和相關東西的時候會用到。
強引用在swift中幾乎隨處可見。實際上聲明一個屬性（property）的時候默認就是一個強引用。通常在關系層級是線性的時候用強引用問題不大。當強引用從父層級流向子層級的時候，這個強引用的使用總是沒問題。
這有個強引用的例子。

class Kraken {   
    let tentacle=Tentacle() //對子層級的強引用。 
} 
class Tentacle { 
    let sucker=Sucker()    //對子層級的強引用。 
} 
class Sucker{} 
 
*/Kraken的意思是海妖，Tentacle的意思是觸手，sucker的意思是吸盤...譯者注/* 

例子中是一個線性的關系層級。Kraken有一個指向Tentacle實例的強引用，Tentacle實例又有一個指向Sucker實例的強引用。引用關系的流向從父層級（Kraken）一直向下流到子層級（Sucker）。
在animation block里引用層級也是類似的：

UIView.animateWithDuration(0.3) { 
    self.view.alpha=0.0 
} 

因為animateWithDuration是UIView的一個靜態方法，這里的閉包是父層級，self是子層級。
如果子層級想引用父層級怎么辦？這就是我們要用弱引用和unowned引用的地方。

WEAK AND UNOWNED REFERENCES - 弱引用和UNOWNED引用

WEAK - 弱引用

弱引用就是一個保護不了其所指對象不被ARC回收的指針。強引用能讓它對象的保留計數增加1，弱引用不能。
swift中，所有的弱引用都是非常量的可選類型（non-constant Optionals）（想一下var和let的關系），因為在沒有其他強引用指向的時候，這個引用能，并且會被改變成nil。
例如下面的代碼就不能通過編譯：

class Kraken { 
    weak let tentacle = Tentacle() //let是一個常量。所有的weak變量都必須是可變（mutable）的。 
} 

因為tentacle是一個let常量。Let由于規范限制使得其在運行時不能夠被改變。因為弱引用變量（weak variables）在沒有任何強引用指向它們時是會被改變成nil的，所以swift編譯器要求你將弱引用變量聲明成var。
那些會出現潛在的強引用循環的地方就是使用弱引用變量的關鍵之處。強引用循環發生在兩個對象彼此之間都用強引用指向對方的情況下，ARC不會對其中任何一個實例發出正確的釋放信號代碼（release message code），因為這兩個實例正彼此保護著對方。這有個來自Apple的簡潔圖片，非常明了的展示了這點：

下面是一個能展示強引用循環的很棒的例子，其中用到了NSNotification API（還是比較新的API）。看看下面的代碼吧：

class Kraken { 
    var notificationObserver: ((NSNotification) -> Void)?  
    init() {notificationObserver = NSNotificationCenter.defaultCenter().addObserverForName("humanEnteredKrakensLair", object: nil, queue: NSOperationQueue.mainQueue()) { notification in 
            self.eatHuman() 
           } 
    } 
    deinit { 
            if notificationObserver != nil { 
                NSNotificationCenter.defaultCenter.removeObserver(notificationObserver) 
            } 
    } 
} 

到這兒我們就搞出了一個強引用循環。你看，swift里的閉包與Objective-C里的blocks極像。如果一個變量是在閉包外面聲明的，在閉包里面引用這個變量就會產生出另一個強引用。此種情況下僅有的例外就是使用值類型的變量，比如swift里的Ints，Strings，Arrays和Dictionaries。
這里NSNotificationCenter保留了一個閉包，當你調用eatHuman()方法時這個閉包以強引用的方式捕獲了self。問題是：我們直到deinit的時候才清空這個閉包，但是deinit永遠不會被ARC調用，因為這個閉包有一個對Kraken實例的強引用！
用NSTimers和NSThread的地方也會出現這種情況。
解決方法是在閉包的捕獲列表（capture list）里使用一個對self的弱引用。這就打破了強引用循環。到了這里，我們的對象引用關系圖就變成了這樣：

把self變成weak不會給self的保留計數加1，這就能讓ARC在正確的時間將其合理的銷毀。
要在閉包里使用weak和unowned變量的話，需要在閉包體內用[]語法。例如：

let closure = { [weak self] in 
    self?.doSomething() //記住，所有的weak變量都是可選類型。 
} 

為什么weak self會在方括號里？這看起來很怪！Swift中我們看見方括號就會想到數組。你猜怎么著？你可以在閉包里指定多個待捕獲的值！比如：

let closure = { [weak self, unowned krakenInstance] in //瞧這個捕獲了多個值的數組 
    self?.doSomething() //weak變量是可選類型 
    krakenInstance.eatMoreHumans() //unowned 變量不是可選類型 
} 

看起來就像數組多了吧？現在你就知道了為什么捕獲值是寫在方括號里的。好，用我們現在所學到的，在上面notification代碼的閉包捕獲列表中加上[weak self]就可以解決強引用循環的問題：

NSNotificationCenter.defaultCenter().addObserverForName("humanEnteredKrakensLair", object: nil, queue: NSOperationQueue.mainQueue()) { [weak self] notification in //使用捕獲列表消除了強引用循環！ 
    self?.eatHuman() //self現在是一個可選類型了！ 
} 

#p#

用到weak和unowned變量的另外一個地方就是使用協議（protocol）在多個class間去實現委托（delegation）的情況，因為swift中class是引用類型。結構體（structs）和enum（枚舉）也能遵循協議，但是它們是值類型。如果一個父類帶上一個子類使用委托，像這樣：

class Kraken: LossOfLimbDelegate { 
    let tentacle = Tentacle() 
    init() { 
        tentacle.delegate = self 
    } 
    func limbHasBeenLost() { 
        startCrying() 
    } 
} 
protocol LossOfLimbDelegate { 
    func limbHasBeenLost() 
} 
class Tentacle { 
    var delegate: LossOfLimbDelegate? 
    func cutOffTentacle() { 
        delegate?.limbHasBeenLost() 
    } 
} 

那么我們就需要用weak變量。在這個例子里Tentacle以它所擁有的代理屬性（delegate property）的形式持有一個對Kraken的強引用，同時Kraken在它的tentacle屬性中也有一個對Tentacle的強引用。我們在代理聲明之前加上一個weak說明符來解決：

weak var delegate: LossOfLimbDelegate? 

你說什么？編譯不通過？好吧，因為非class類型的協議不能被標識為weak。
此時，我們得用一個唯類協議（class protocol）來使得代理屬性能夠標識成weak。讓我們的協議繼承:class。

protocol LossOfLimbDelegate: class { //Protocol 現在繼承了class 
    func limbHasBeenLost() 
} 

什么時候不用:class? Apple的文檔里說：

當一個協議需求所定義的行為（behavior）能夠確保或要求遵循這個協議的類型是引用類型而非值類型的時候，使用唯類協議。

基本上，如果你自己代碼的引用層級和我上面寫的一樣的話，你就加上:class。對于使用結構體或者枚舉的情況，就不需要:class了，因為結構體和枚舉是值類型，class是引用類型。

UNOWNED

弱引用和unowned引用本質上是一樣的。Unowned引用并不增加它所引用對象的保留計數。然而swift語言中unowned引用的額外的優點是它為非可選類型。這使得它用起來更方便，不用再去引入可選綁定（optional binding）。這和隱式可選類型（Implicity Unwarpped Optionals）沒什么區別。
到這里就有點兒亂了。弱引用和unowned引用都不增加保留計數。它們都用來解決強引用循環的問題。那么我們什么時候用它們？Apple的文檔說：

當一個引用在其生命周期中變為nil時依然合理，就把這個引用定義為弱引用。相反，如果你事先知道一個引用在被設置好了之后不會再變成nil，就把它定義成unowned引用。

你知道答案了：就和隱式可選類型一樣，如果你能確保這個引用在被用到的時候肯定不是nil的話，就用unowned，如果不確保，就得用弱引用。
下面是一個典型的例子，一個class的閉包中捕獲的self不會變成nil，這就生成了一個強引用循環：

class RetainCycle { 
    var closure: (() -> Void)! 
    var string = "Hello" 
    init() { 
        closure = { 
            self.string = "Hello, World!" 
        } 
    } 
} 
//初始化class，并激活強引用循環。 
let retainCycleInstance = RetainCycle() 
retainCycleInstance.closure() //此時我們可以確保閉包中捕獲的self不會再是nil了。此后的任何代碼（尤其是改變self的引用的代碼）都需要判斷一下unowned是否在這兒還起作用。 

上面的例子里，閉包以強引用的形式捕獲了self，同時self通過自己的閉包屬性也保留了一個對該 閉包的強引用，這就造出了強引用循環。簡單的給閉包加一個[unowned self]就能打破這個循環：

closure = { [unowned self] in 
     self.string = "Hello, World!" 
} 

因為我們在初始化RetainCycle類之后立即調用了閉包，我們就可以認為self不會再是nil了。

結論

強引用循環很不好。但是認真的寫代碼，考慮清楚自己的引用層級，合理的選用weak和unowned引用就可以避免內存泄露和內存遺棄。希望這篇文章會幫到你。
祝碼農們編程愉快！