Under what circumstances are atomic properties useful?

Question

Objective-C properties are by default atomic, which ensures that accessors are atomic, but do not provide overall thread safety (like this question ). My question is that in most concurrency scenarios, there are no redundant atom properties? For instance:

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 thought that perhaps atomic properties would be useful for preventing locks when working with immutable objects, but since immutable objects can point to mutable objects in Objective-C, this doesn't help much:

@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
}

, , (, , ), :

• , ;
• , , (, a NSString NSArray of ).

- ? ?

Answer 1

; atomic , , .

, atomic .

.

[ ] ?