不，有些时候你肯定不想使用[u主self]。有时你想让闭包捕获self以确保在闭包被调用时它仍然存在。

示例:发起异步网络请求

如果您正在发出异步网络请求，您确实希望闭包在请求完成时保持自我。该对象可能已经被释放，但您仍然希望能够处理请求的完成。

何时使用无主自我或弱自我

真正需要使用[un主self]或[weak self]的唯一时候是创建强引用循环的时候。强引用循环是指存在一个所有权循环，其中对象最终拥有彼此(可能通过第三方)，因此它们永远不会被释放，因为它们都确保彼此存在。

In the specific case of a closure, you just need to realize that any variable that is referenced inside of it, gets "owned" by the closure. As long as the closure is around, those objects are guaranteed to be around. The only way to stop that ownership, is to do the [unowned self] or [weak self]. So if a class owns a closure, and that closure captures a strong reference to that class, then you have a strong reference cycle between the closure and the class. This also includes if the class owns something that owns the closure.

特别是在视频中的例子中

在幻灯片上的示例中，TempNotifier通过onChange成员变量拥有闭包。如果它们没有声明self为无主的，闭包也将拥有self，从而创建一个强引用循环。

无主和弱的区别

u主和weak的区别在于weak被声明为Optional，而u主则不是。通过声明它为弱，你可以处理闭包中某个时刻它可能为nil的情况。如果你试图访问一个无主变量，而这个变量恰好是nil，它将使整个程序崩溃。所以只有当你确定这个变量在闭包存在的时候才使用un主

我想我应该为视图控制器添加一些具体的例子。很多解释，不仅仅是在Stack Overflow上，真的很好，但我用现实世界的例子工作得更好(@drewag在这方面有一个很好的开始):

If you have a closure to handle a response from a network requests use weak, because they are long lived. The view controller could close before the request completes so self no longer points to a valid object when the closure is called. If you have closure that handles an event on a button. This can be unowned because as soon as the view controller goes away, the button and any other items it may be referencing from self goes away at the same time. The closure block will also go away at the same time. class MyViewController: UIViewController { @IBOutlet weak var myButton: UIButton! let networkManager = NetworkManager() let buttonPressClosure: () -> Void // closure must be held in this class. override func viewDidLoad() { // use unowned here buttonPressClosure = { [unowned self] in self.changeDisplayViewMode() // won't happen after vc closes. } // use weak here networkManager.fetch(query: query) { [weak self] (results, error) in self?.updateUI() // could be called any time after vc closes } } @IBAction func buttonPress(self: Any) { buttonPressClosure() } // rest of class below. }

根据Apple-doc

弱引用总是可选类型，并且是自动的 当它们引用的实例被释放时变为nil。 如果捕获的引用永远不会变成nil，那么它应该始终被捕获为无主引用，而不是弱引用

的例子,

    // if my response can nil use  [weak self]
      resource.request().onComplete { [weak self] response in
      guard let strongSelf = self else {
        return
      }
      let model = strongSelf.updateModel(response)
      strongSelf.updateUI(model)
     }

    // Only use [unowned self] unowned if guarantees that response never nil  
      resource.request().onComplete { [unowned self] response in
      let model = self.updateModel(response)
      self.updateUI(model)
     }

以下是来自苹果开发者论坛的精彩语录:

无主vs无主(安全)vs无主(不安全)

unowned(safe) is a non-owning reference that asserts on access that the object is still alive. It's sort of like a weak optional reference that's implicitly unwrapped with x! every time it's accessed. unowned(unsafe) is like __unsafe_unretained in ARC—it's a non-owning reference, but there's no runtime check that the object is still alive on access, so dangling references will reach into garbage memory. unowned is always a synonym for unowned(safe) currently, but the intent is that it will be optimized to unowned(unsafe) in -Ofast builds when runtime checks are disabled.

无主vs弱

unowned actually uses a much simpler implementation than weak. Native Swift objects carry two reference counts, and unowned references bump the unowned reference count instead of the strong reference count. The object is deinitialized when its strong reference count reaches zero, but it isn't actually deallocated until the unowned reference count also hits zero. This causes the memory to be held onto slightly longer when there are unowned references, but that isn't usually a problem when unowned is used because the related objects should have near-equal lifetimes anyway, and it's much simpler and lower-overhead than the side-table based implementation used for zeroing weak references.

更新:在现代Swift中，weak内部使用与un物主相同的机制。所以这个比较是不正确的，因为它比较了Objective-C的弱和Swift的unonwed。

原因

What is the purpose of keeping the memory alive after owning references reach 0? What happens if code attempts to do something with the object using an unowned reference after it is deinitialized? The memory is kept alive so that its retain counts are still available. This way, when someone attempts to retain a strong reference to the unowned object, the runtime can check that the strong reference count is greater than zero in order to ensure that it is safe to retain the object. What happens to owning or unowned references held by the object? Is their lifetime decoupled from the object when it is deinitialized or is their memory also retained until the object is deallocated after the last unowned reference is released? All resources owned by the object are released as soon as the object's last strong reference is released, and its deinit is run. Unowned references only keep the memory alive—aside from the header with the reference counts, its contents is junk.

兴奋,是吗?

如果以上都说不通:

博士tl;

就像一个隐式打开的可选选项，如果你能保证 引用在它的使用点不会为nil，使用无主。 如果不是，那么你应该使用weak。

解释:

我检索了以下在:弱无主链接。从我收集到的，无主self不能为nil，但弱self可以，并且无主self可以导致悬空指针…这在Objective-C中是臭名昭著的。希望能有所帮助

“无主弱引用和无主引用行为相似，但并不相同。”

Unowned references, like weak references, do not increase the retain count of the object being referred. However, in Swift, an unowned reference has the added benefit of not being an Optional. This makes them easier to manage rather than resorting to using optional binding. This is not unlike Implicitly Unwrapped Optionals . In addition, unowned references are non-zeroing. This means that when the object is deallocated, it does not zero out the pointer. This means that use of unowned references can, in some cases, lead to dangling pointers. For you nerds out there that remember the Objective-C days like I do, unowned references map to unsafe_unretained references.

这就是让人有点困惑的地方。

弱引用和无主引用都不会增加保留计数。

它们都可以用来打破保留循环。那么我们什么时候使用它们呢?

苹果公司的文件显示:

“当一个引用在其生命周期的某个时间点变成nil是有效的时，就使用弱引用。相反，当你知道在初始化过程中设置的引用永远不会为nil时，使用无主引用。”

unowned is similar to weak they don't a retained object from being destroyed, but weak variables turned to nil when the object its a reference to no longer exists, which we can handle with the normal checking of nils, unowned will just become garbage, you can't tell they are no longer garbage and using them will crash. The problem with weak is if an object has references to it by weak variables, when its destroyed, it has to go through every reference to it and set that variable to nil, this clearly is going to be expensive, using unowned instead is going just crash and finding this kind of bug is going to be difficult. One place to use unowned is if you are creating some carefully contained datatype, which has a clear interface, and its internals are not directly accessible, for you implementation it may be useful to have lots of circular references but that are self contained, you can used unowned references to let you break those circular references, with out the expense of weak variables, for example you may have a node tree, and each node needs has to have a reference to its parent, deleting a node is going to delete all its children, so there is no point of all the children having to have all there parent references set to nil.