swift - 弱小的自己去哪儿了？

Question

我经常这样做，

let when = DispatchTime.now() + 2.0
DispatchQueue.main.asyncAfter(deadline: when) {
   beep()
}

在一个应用中我们经常这样做

tickle.fresh(){
    msg in
    paint()
}

但是如果你这样做

let when = DispatchTime.now() + 2.0
DispatchQueue.main.asyncAfter(deadline: when) {
   tickle.fresh(){
      msg in
      paint()
   }
}

当然你必须这个

let when = DispatchTime.now() + 2.0
DispatchQueue.main.asyncAfter(deadline: when) { [weak self] _ in
   tickle.fresh(){
      msg in
      self?.paint()
   }
}

或者，也许这个

let when = DispatchTime.now() + 2.0
DispatchQueue.main.asyncAfter(deadline: when) {
   tickle.fresh(){
      [weak self] msg in
      self?.paint()
   }
}

或者这个

let when = DispatchTime.now() + 2.0
DispatchQueue.main.asyncAfter(deadline: when) { [weak self] _ in
   tickle.fresh(){
      [weak self] msg in
      self?.paint()
   }
}

我们应该做什么？

所有三个建议似乎 都非常有效。这里的全部含义是什么？应该做什么？强引用是弱引用，弱引用还是强引用？生存还是毁灭？就是这个问题!

Answer 1

首先，请注意您通常不需要担心 DispatchQueue.main.asyncAfter 的保留周期，因为闭包将在某个点执行.因此，无论您是否弱捕获 self，您都不会创建永久保留周期(假设 tickle.fresh 也不会)。

是否将[weak self] 捕获列表放在外部asyncAfter 闭包中完全取决于您是否希望self保留直到调用闭包(在您设置的时间之后)。如果您不需要 self 在调用闭包之前保持事件状态，请将 [weak self] 放入，如果需要，则不要放入。

是否将 [weak self] 放在内部闭包(传递给 tickle.fresh 的闭包)取决于您是否已经弱捕获 self 在外层闭包中。如果还没有，则可以放置 [weak self] 以防止内部闭包保留它。但是，如果外部闭包已经弱捕获了 self，那么内部闭包将已经对 self 进行弱引用，从而添加 [weak self] 到内部闭包将无效。

总结一下:

---

DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
   tickle.fresh { msg in
      self.paint()
   }
}

self 将被外部和内部闭包保留。

---

DispatchQueue.main.asyncAfter(deadline: .now() + 2) { [weak self] in
   tickle.fresh { msg in
      self?.paint()
   }
}

self 不会被任何一个闭包保留。

---

DispatchQueue.main.asyncAfter(deadline: .now() + 2) { [weak self] in
   tickle.fresh { [weak self] msg in
      self?.paint()
   }
}

与上面相同，内部闭包的附加 [weak self] 没有任何效果，因为 self 已经被外部闭包弱捕获。

---

DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
   tickle.fresh { [weak self] msg in
      self?.paint()
   }
}

self 将被外部闭包保留，但不会被内部闭包保留。

---

当然，可能你不希望 self 被外层闭包保留，但你确实希望它被内层闭包保留.在这种情况下，您可以在外部闭包中声明一个局部变量以保持对 self 的强引用，然后您可以在内部闭包中捕获:

DispatchQueue.main.asyncAfter(deadline: .now() + 2) { [weak self] in
   guard let strongSelf = self else { return }
   tickle.fresh { msg in
      strongSelf.paint()
   }
}

现在，self 不会被外部闭包保活，但是一旦它被调用，如果 self 仍然存在，它将被内部闭包保活直到该闭包被解除分配。

---

回应:

Is a strong reference to a weak reference, a weak or strong reference?

弱引用被实现为可选值类型。因此，您不能直接对一个实例进行强引用——相反，您首先必须对其进行解包，然后对底层实例进行强引用。在这种情况下，您只是在处理强引用(就像我上面使用 strongSelf 的示例一样)。

但是，如果一个弱引用被装箱(这种情况发生在闭包捕获中——值类型将被放入一个堆分配的盒子中)——那么你确实可以对该盒子有一个强引用.这样做的效果相当于对原始实例的弱引用，你只是有一点不可见的额外间接。

事实上，这正是在外部闭包弱捕获 self 而内部闭包“强捕获”弱引用的示例中发生的情况。结果是两个闭包都不会保留 self。