Objective-C properties default to atomic, which ensures that accessors are atomic but doesn't ensure overall thread-safety (as per this question). My question is, aren't atomic properties redundant in most concurrency scenarios? For example:
Scenario 1: mutable properties
@interface ScaryMutableObject : NSObject {}
@property (atomic, readwrite) NSMutableArray *stuff;
@end
void doStuffWith(ScaryMutableObject *obj) {
[_someLock lock];
[obj.stuff addObject:something]; //the atomic getter is completely redundant and could hurt performance
[_someLock unlock];
}
//or, alternatively
void doStuffWith(ScaryMutableObject *obj) {
NSMutableArray *cachedStuff = obj.stuff; //the atomic getter isn't redundant
[_someLock lock];
[cachedStuff addObject:something]; //but is this any more performant than using a nonatomic accessor within the lock?
[_someLock unlock];
}
Scenario 2: immutable properties
I was thinking that maybe atomic properties would be useful for avoiding locks when working with immutable objects, but since immutable objects can point to mutable objects in Objective-C, this isn't really much help:
@interface SlightlySaferObject : NSObject {}
@property (atomic, readwrite) NSArray *stuff;
@end
void doStuffWith(SlightlySaferObject *obj) {
[[obj.stuff objectAtIndex:0] mutateLikeCrazy];//not at all thread-safe without a lock
}
The only scenarios I can think of where it's safe to use atomic accessors without a lock (and therefore worth using atomic properties at all) are:
- Working with properties that are primitives;
- Working with properties that are
guaranteed to be immutable and not
to point to mutable objects (such as
an
NSStringor anNSArrayof immutable objects).
Am I missing something? Are there any other good reasons to use atomic properties?
