弱小的自己去哪儿了？

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] 放入，如果需要，则不要放入。

是否在内部闭包（传递给 tickle.fresh 的那个）上放置 [weak self] 取决于您是否已经在外部闭包中弱捕获了 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 的示例一样）。

但是，如果弱引用是 boxed（这种情况发生在闭包捕获中——值类型将被放入 heap-allocated 盒子中）——那么你确实可以对那个盒子有强烈的参考。这样做的效果相当于对原始实例的弱引用，你只是有一个不可见的额外间接位。

事实上，这正是在外部闭包弱捕获 self 和内部闭包 'strongly captures' 弱引用的示例中发生的情况。结果是两个闭包都不保留 self.

弱小的自己去哪儿了？

Where does the weak self go?

weak-references

swift

我们应该做什么？