class方法，其中self在块中使用

Question

I've got a class method that uses dispatch_once to create a static object. Inside the dispatch_once block I use [self class] and was wondering if I need to use a weak reference to self to avoid a retain cycle?

+ (NSArray *)accountNames{
    static NSArray *names = nil;
    static dispatch_once_t predicate;
    dispatch_once(&predicate, ^{
        names = [[[self class] accounts] allKeys];
        names = [names sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)];
    });
    return names;
}

If I use a weak reference to self I get a warning:

+ (NSArray *)accountNames{
    static NSArray *names = nil;
    static dispatch_once_t predicate;
    __weak TUAccount *wself = self;
    dispatch_once(&predicate, ^{
        names = [[[wself class] accounts] allKeys];
        names = [names sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)];
    });
    return names;
}

Incompatible pointer types initializing 'TUAccount *__weak' with an expression of type 'const Class'

Because I get a warning I don't think I need to use a weak reference to self in this case but I wanted to see what you guys thought.

Answer 1

There is no reason to worry about a retain cycle here, because it's meaningless to retain or release a class object -- retain and release simply have no effect.

Your attempt at making a weak reference is wrong, because you are taking a class object self and trying to cast it to an instance of TUAccount . The two are completely different things.

Also, you can simplify:

names = [[[self class] accounts] allKeys];

Since self is already a class, [self class] == self, so do this instead:

names = [[self accounts] allKeys];

Answer 2

I have checked one more time iOS SDK Docs and found next:

Objective-C Objects

In a manually reference-counted environment, local variables used within the block are retained when the block is copied. Use of instance variables within the block will cause the object itself to be retained. If you wish to override this behavior for a particular object variable, you can mark it with the __block storage type modifier.

If you are using ARC, object variables are retained and released automatically as the block is copied and later released.

• Note: In a garbage-collected environment, if you apply both __weak and __block modifiers to a variable, then the block will not ensure that it is kept alive.

If you use a block within the implementation of a method, the rules for memory management of object instance variables are more subtle:

• If you access an instance variable by reference, self is retained;
• If you access an instance variable by value, the variable is retained.

The following examples illustrate the two different situations:

dispatch_async(queue, ^{
    // instanceVariable is used by reference, self is retained
    doSomethingWithObject(instanceVariable);
});


id localVariable = instanceVariable;
dispatch_async(queue, ^{
    // localVariable is used by value, localVariable is retained (not self)
    doSomethingWithObject(localVariable);
});

Conclusion: I assume that there is no problem with using self in block. It will be retained and after execution released.

Moreover, you are not storing block in memory and using it directly. So it is copied to the heap, executed and pushed from it. I don't see any retain cycles.

Hope I am right!