标签: reference-cycle

我在python中实现了一个观察者可观察的模式:

这是Observable类:

class Observable(object):
    def __init__(self, value):
        self.value = value
        self.observers = []

    def set(self, value):
        old = self.value
        self.value = value
        self.notifyObservers(old, self.value)

    def get(self):
        return self.value

    def addObserver(self, o):
        self.observers.append(o)

    def removeObserver(self, o):
        if o in self.observers:
            self.observers.remove(o)

    def notifyObservers(self, old, new):
        for o in self.observers:
            o.valueChanged(old, new)

这是一个观察者:

class Observer(object):
    def __init__(self, foo):
        self.foo = foo
        self.foo.addObserver(self)

    def __del__(self):
        print('Observer.__del__ called')
        self.foo.removeObserver(self)

    def valueChanged(self, old, new):
        print('foo changed from %s to %s' % (old, new))

代码按预期工作.

但是我需要将 …

我有一个对重复调用闭包的对象UIViewController的引用。Timer对象在其块中Timer捕获。self据我了解，这会导致retains cycle视图控制器和块之间的关系。有一个逻辑将定时器设置为nil，然后保留周期被打破，但它可能不会被执行。

我的问题如下：视图控制器将随着应用程序的存在而存在（至少在当前的实现中）。在这种情况下 - 我应该如何最好地处理这个保留周期？我应该忽略它吗，因为视图控制器无论如何都不会被释放。我应该考虑未来可能发生的变化并用unowned或weak参考文献以及哪一个来处理它。我想这应该是unowned因为计时器仅由视图控制器保留，并且一旦视图控制器被释放，它应该被释放，但不确定我是否遗漏了一些东西。先感谢您。下面的代码是我正在谈论的内容的简单示例。Class A是视图控制器。

class A {

    var timer: Timer? = nil
    var varToReference: Int = 0

    func startTimer() {
        timer = Timer.scheduledTimer(withTimeInterval: 2, repeats: true, block: {  (theTimer) in

            self.varToReference += 1

        })
    }

    func stopTimer() {
        if let theTimer = timer {
            theTimer.invalidate()
            timer = nil
        }
    }

    func onAdapterStarts() {
        self.startTimer()
    }

    func onAdapterStops(){
        self.stopTimer()
    }

    deinit …

假设我想@synchronized(self)在一个区块内做.我想这会导致保留周期,所以通常我们会像这样重写它:

-(void)myMethod
{
    __weak TheClass * weakSelf = self;
    dispatch_async(dispatch_get_main_queue(),
    ^{
        TheClass * strongSelf = weakSelf;
        if(strongSelf == nil)
        {
            return;
        }

        @synchronized(strongSelf)
        {
            //mutex code
        }
    }
}

我的问题是,当你以@synchronized这种方式使用指令时,它是否相当于@synchronized(self)？