遞歸協議的快速內存管理

Question

考慮swift中的以下類，它與自身保持遞歸關系

class OctupPromisable {

    var promise: OctupPromisable?

    weak var chainedPromise: OctupPromisable?

    func then(octupPromisable: OctupPromisable) -> OctupPromisable? {
        self.promise = octupPromisable
        octupPromisable.chainedPromise = self
        return self.promise
    }

    func start() {
        if nil == self.chainedPromise {
            self.fire(nil)
        }else {
            self.chainedPromise!.start()
        }
    }
}

用作這樣的：

OctupPromisable()
.then(OctupPromisable())
.then(OctupPromisable())
.start()

當我在chainedPromise弱的情況下調用start時，它總是導致chainedPromise為nil，因此start方法永遠不會遞歸。

使chainedPromise變強，會導致start方法遞歸並正常工作。 但是這樣做我是不是會創建一個強大的循環關系導致內存泄漏？ 如果是這樣，可以做些什么來實現遞歸並避免內存泄漏？

謝謝！

Answer 1

使鏈接過程變得強大，但在使用它之后，將其設置為nil 。 你完成了它，所以你不需要再擁有一個強大的參考。 如果沒有其他強引用，則將取消分配該對象。

Answer 2

如果執行后不需要保留引用，則可以使用強引用並以遞歸方式釋放內部promise，因此當第一個promise取消分配時，它不會導致內存泄漏。

我無法測試代碼，但它是這樣的：

class OctupPromisable {

  weak var promise: OctupPromisable? // Make it weak to avoid reference cycle
  var chainedPromise: OctupPromisable? // Make it a strong reference
  func start() {
    if nil == self.chainedPromise {
      self.fire(nil)
    } else {
      self.chainedPromise!.start()
      self.chainedPromise = nil // Will be deallocated after all 'start' calls 
    }
  }
}