why this RACObserve block caused retain cycle?

Question

Consider I in my view controller, I added RACObserve of property of Singleton, and inside subscribNext I have a self reference in it. The code is as below:

[RACObserve([Singleton shared], singletonFlag) subscribeNext:^(NSNumber *singletonFlag) {
        self.flag = [singletonFlag boolValue];
    }];

Based on my understanding, self don't hold a strong reference of the block(while block hold a strong reference of self), this shouldn't cause retain cycle. I have read memory management of reactive cocoa as well https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/Documentation/Legacy/MemoryManagement.md In which they provide an example as

[RACObserve(self, username) subscribeNext:^(NSString *username) {
    [self validateUsername];
}];

I totally understand why it caused the retain cycle in above case and we need a weak self inside the block. I am confused why in the first case, it will cause a retain cycle. To confirm this, just paste that code snippet after viewDidLoad and see whether the view controller was dealloc-ed when it should be. If you need see more implementations of the singleton, this is the code,

@interface Singleton : NSObject
@property (readwrite,nonatomic) BOOL singletonFlag;
@end

@implementation Singleton
+ (Singleton *)shared {
    static dispatch_once_t pred = 0;
    __strong static id _sharedObject = nil;
    dispatch_once(&pred, ^{
        _sharedObject = [[self alloc] init];
    });
    return _sharedObject;
}

- (id)init {
    if (self = [super init]) {
        NSLog(@"init of %@",NSStringFromClass(self.class));
    }
    return self;
}
@end

Anyone enlighten me about this?

It's not really a cycle, but the singleton never gets deallocated due to being a singleton, so the block which holds a strong reference to your view controller will never let go of that reference. — dan
thanks @dan I think I get it now, which means this subscribeNext block is not like our normal defined blocks(which was dealloc after block execution), am I correct to say that? — air_bob

Cosyn Cosyn · Accepted Answer · 2015-10-07T03:37:03

The internal implementation is quite complicated, It's not important whether there is a real retain cycle.

Here the reason why memory leaks is just the same in your two examples:

self is retained by the block
The block is retained by an internal subscriber object
The subscriber is retained by some internal thing of the RACObserve signal until the signal terminates.
The RACObserve signal terminates when either the target (the singleton instance) or self (the RACObserve micro is implicitly using self) is deallocated.

But now the singleton instance won't dealloc, and self won't dealloc neither since it's already retained. So the signal never terminates, then memory leaks.

why this RACObserve block caused retain cycle?

3 Answers