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

咱們開始吧

ARC

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

STRONG - 強(qiáng)引用

從什么是強(qiáng)引用說起。它本質(zhì)上是一個(gè)普通的引用（指針或者其他有相同意思的東西），但是它特殊在能夠通過將該引用指向?qū)ο螅╫bject）的保留計(jì)數(shù)（retain count）增加1來保護(hù)這個(gè)對象不被ARC回收。實(shí)質(zhì)上，哪怕任何一個(gè)東西的一個(gè)強(qiáng)引用指向了這個(gè)對象，這個(gè)對象就不會被回收。記住這點(diǎn)，待會兒講強(qiáng)引用循環(huán)和相關(guān)東西的時(shí)候會用到。
強(qiáng)引用在swift中幾乎隨處可見。實(shí)際上聲明一個(gè)屬性（property）的時(shí)候默認(rèn)就是一個(gè)強(qiáng)引用。通常在關(guān)系層級是線性的時(shí)候用強(qiáng)引用問題不大。當(dāng)強(qiáng)引用從父層級流向子層級的時(shí)候，這個(gè)強(qiáng)引用的使用總是沒問題。
這有個(gè)強(qiáng)引用的例子。

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

例子中是一個(gè)線性的關(guān)系層級。Kraken有一個(gè)指向Tentacle實(shí)例的強(qiáng)引用，Tentacle實(shí)例又有一個(gè)指向Sucker實(shí)例的強(qiáng)引用。引用關(guān)系的流向從父層級（Kraken）一直向下流到子層級（Sucker）。
在animation block里引用層級也是類似的：

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

因?yàn)閍nimateWithDuration是UIView的一個(gè)靜態(tài)方法，這里的閉包是父層級，self是子層級。
如果子層級想引用父層級怎么辦？這就是我們要用弱引用和unowned引用的地方。

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

WEAK - 弱引用

弱引用就是一個(gè)保護(hù)不了其所指對象不被ARC回收的指針。強(qiáng)引用能讓它對象的保留計(jì)數(shù)增加1，弱引用不能。
swift中，所有的弱引用都是非常量的可選類型（non-constant Optionals）（想一下var和let的關(guān)系），因?yàn)樵跊]有其他強(qiáng)引用指向的時(shí)候，這個(gè)引用能，并且會被改變成nil。
例如下面的代碼就不能通過編譯：

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

因?yàn)閠entacle是一個(gè)let常量。Let由于規(guī)范限制使得其在運(yùn)行時(shí)不能夠被改變。因?yàn)槿跻米兞浚╳eak variables）在沒有任何強(qiáng)引用指向它們時(shí)是會被改變成nil的，所以swift編譯器要求你將弱引用變量聲明成var。
那些會出現(xiàn)潛在的強(qiáng)引用循環(huán)的地方就是使用弱引用變量的關(guān)鍵之處。強(qiáng)引用循環(huán)發(fā)生在兩個(gè)對象彼此之間都用強(qiáng)引用指向?qū)Ψ降那闆r下，ARC不會對其中任何一個(gè)實(shí)例發(fā)出正確的釋放信號代碼（release message code），因?yàn)檫@兩個(gè)實(shí)例正彼此保護(hù)著對方。這有個(gè)來自Apple的簡潔圖片，非常明了的展示了這點(diǎn)：

下面是一個(gè)能展示強(qiáng)引用循環(huán)的很棒的例子，其中用到了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) 
            } 
    } 
} 

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

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

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

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

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

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

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

#p#

用到weak和unowned變量的另外一個(gè)地方就是使用協(xié)議（protocol）在多個(gè)class間去實(shí)現(xiàn)委托（delegation）的情況，因?yàn)閟wift中class是引用類型。結(jié)構(gòu)體（structs）和enum（枚舉）也能遵循協(xié)議，但是它們是值類型。如果一個(gè)父類帶上一個(gè)子類使用委托，像這樣：

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變量。在這個(gè)例子里Tentacle以它所擁有的代理屬性（delegate property）的形式持有一個(gè)對Kraken的強(qiáng)引用，同時(shí)Kraken在它的tentacle屬性中也有一個(gè)對Tentacle的強(qiáng)引用。我們在代理聲明之前加上一個(gè)weak說明符來解決：

weak var delegate: LossOfLimbDelegate? 

你說什么？編譯不通過？好吧，因?yàn)榉莄lass類型的協(xié)議不能被標(biāo)識為weak。
此時(shí)，我們得用一個(gè)唯類協(xié)議（class protocol）來使得代理屬性能夠標(biāo)識成weak。讓我們的協(xié)議繼承:class。

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

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

當(dāng)一個(gè)協(xié)議需求所定義的行為（behavior）能夠確保或要求遵循這個(gè)協(xié)議的類型是引用類型而非值類型的時(shí)候，使用唯類協(xié)議。

基本上，如果你自己代碼的引用層級和我上面寫的一樣的話，你就加上:class。對于使用結(jié)構(gòu)體或者枚舉的情況，就不需要:class了，因?yàn)榻Y(jié)構(gòu)體和枚舉是值類型，class是引用類型。

UNOWNED

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

當(dāng)一個(gè)引用在其生命周期中變?yōu)閚il時(shí)依然合理，就把這個(gè)引用定義為弱引用。相反，如果你事先知道一個(gè)引用在被設(shè)置好了之后不會再變成nil，就把它定義成unowned引用。

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

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

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

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

因?yàn)槲覀冊诔跏蓟疪etainCycle類之后立即調(diào)用了閉包，我們就可以認(rèn)為self不會再是nil了。

結(jié)論

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