"Capturing 'self' strongly in this block is likely to lead to a retain cycle" using Reachability

Question

I'm trying to edit a variable inside the Reachability block using Objective-C, this is the code:

- (void)testInternetConnection
{
    internetReachableFoo = [Reachability reachabilityWithHostname:@"www.google.com"];
    // Internet is reachable
    internetReachableFoo.reachableBlock = ^(Reachability*reach)
    {
        // Update the UI on the main thread
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"Connessione ad Internet disponibile");
            checkConnection = YES;
            if(!lastConnectionState)
            {
                lastConnectionState = YES;
                if(doItemsDownload)
                    [self displayChoice];
            }
        });
    };

    // Internet is not reachable
    internetReachableFoo.unreachableBlock = ^(Reachability*reach)
    {
        // Update the UI on the main thread
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"Connessione ad Internet non disponibile");
            checkConnection = NO;
            lastConnectionState = NO;
        });
    };

    [internetReachableFoo startNotifier];
}

Where checkConnection; & lastConnectionState; are 2 bool declared on my @interface; The problem is that accessing these variables and calling [self displayChoice]; inside this block gives me the warning: Capturing 'self' strongly in this block is likely to lead to a retain cycle

How can I possibly avoid this error? I tried declaring a WeakSelf and declaring self but I don't know how to do it for the bool variables

possible duplicate of [capturing self strongly in this block is likely to lead to a retain cycle](http://stackoverflow.com/questions/14556605/capturing-self-strongly-in-this-block-is-likely-to-lead-to-a-retain-cycle) — Guillaume Algis, Jun 03 '15 at 15:41
The issue is that your object (self here) retains `internetReachableFoo` and internetReachableFoo retains the block and the block retains the objects to which it refers, like `self`. Nobody in that circle can get freed, because each thing is hanging onto a thing which is hanging onto it (indirectly). The duplicate link's answer explains what to do. — danh, Jun 03 '15 at 15:56

Max · Answer 1 · 2015-06-04T14:17:23.057

Capturing self strongly in a block is not always bad. If a block is being executed right away (UIView animate block for example) there is generally no risk.

The problem arises when self captures a block strongly and the block in turn captures self strongly. In this case self retains the block and the block retains self so neither can be released --> retain cycle!

To avoid this you need to capture self weakly in the block.

__weak typeof(self) = self;  // CREATE A WEAK REFERENCE OF SELF
__block BOOL blockDoItemsDownload = doItemsDownload;  // USE THIS INSTEAD OF REFERENCING ENVIRONMENT VARIABLE DIRECTLY
__block BOOL blockCheckConnection = checkConnection;
internetReachableFoo.reachableBlock = ^(Reachability*reach)
{
    // Update the UI on the main thread
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"Connessione ad Internet disponibile");
        blockCheckConnection = YES;
        if(!lastConnectionState)
        {
            lastConnectionState = YES;
            if(blockDoItemsDownload)       // Use block variable here
                [weakSelf displayChoice];  // Use weakSelf in place of self
        }
    });
};

declaring the weakSelf worked but what about the 2 boolean values (checkConnection and doItemsDownload? They gives me the same error but I can't declare a bool as __weak, what should I do? — LS_, Jun 04 '15 at 07:13
A block generally makes a copy of any variables referenced from its environment. If you want to modify an environment variable you should use a __block version of it. See the edit in the answer. — Max, Jun 04 '15 at 14:09

score 0 · Answer 2 · answered Jun 03 '15 at 15:46

There is a cocoapod called libextobjc and what it allows you to do is quickly and cleanly weakify and strongify objects.

@weakify(self)
[someblock:^{
    @strongify(self)
}];

As long as you handle self you should be ok. I'm not 100% sure the BOOL values aren't an issue but I think you could do something like this:

BOOL x = YES;
@weakify(self, x)
[someblock:^{
    @strongify(self, x)
}];

"Capturing 'self' strongly in this block is likely to lead to a retain cycle" using Reachability

2 Answers2