Concurrency

// GCD -- the modern way to get back to the main thread.
dispatch_async(dispatch_get_main_queue(), ^{
    self.label.text = result;
});

// The older Foundation spelling, still seen:
[self performSelectorOnMainThread:@selector(updateUI:) withObject:result waitUntilDone:NO];

// An assertion worth keeping in any method that must be on the main thread:
NSAssert([NSThread isMainThread], @"UI update off the main thread");

- (void)addItem:(Item *)item {
    @synchronized (self) {
        [_items addObject:item];
    }
}

@synchronized (_lockToken) { … }

@property (nonatomic, strong) NSLock *lock;

[self.lock lock];
… critical section …
[self.lock unlock];

if ([self.lock tryLock]) { … [self.lock unlock]; }      // non-blocking attempt
[self.lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:1.0]];

@property (atomic, strong) NSMutableArray *items;

// STILL a race, despite `atomic`:
if (self.items.count > 0) {              // atomic read of the pointer
    id first = self.items[0];            // another thread may have emptied it in between
}

// Also still a race -- read-modify-write is three operations:
self.counter = self.counter + 1;

// And `atomic` protects the POINTER, not the object it points at:
[self.items addObject:item];             // completely unprotected

// The main queue -- serial, and bound to the main thread.
dispatch_queue_t main = dispatch_get_main_queue();

// A global concurrent queue at a given quality of service.
dispatch_queue_t global = dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0);

// Your own serial queue -- the workhorse for protecting shared state.
dispatch_queue_t serial = dispatch_queue_create("com.example.serial", DISPATCH_QUEUE_SERIAL);

// Your own concurrent queue.
dispatch_queue_t concurrent = dispatch_queue_create("com.example.concurrent", DISPATCH_QUEUE_CONCURRENT);

// Asynchronous: enqueue and return immediately. The common case.
dispatch_async(global, ^{
    NSData *data = [self expensiveComputation];
    dispatch_async(dispatch_get_main_queue(), ^{
        [self display:data];
    });
});

// Synchronous: enqueue and WAIT. Use sparingly.
__block NSArray *snapshot;
dispatch_sync(serial, ^{
    snapshot = [_items copy];
});

dispatch_group_t group   = dispatch_group_create();
dispatch_queue_t collect = dispatch_queue_create("collect", DISPATCH_QUEUE_SERIAL);

for (NSURL *url in urls) {
    dispatch_group_enter(group);                   // manual enter/leave for async work
    [self fetchURL:url completion:^(NSData *data, NSError *error) {
        // Completion handlers run concurrently, and NSMutableArray is not
        // thread-safe -- funnel the mutation through one serial queue.
        dispatch_async(collect, ^{
            [results addObject:data ?: [NSNull null]];
            dispatch_group_leave(group);           // leave AFTER the append, and on EVERY path
        });
    }];
}

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    [self allDownloadsFinished:results];           // runs when the count returns to zero
});

// At most 4 downloads in flight at once.
dispatch_semaphore_t limit = dispatch_semaphore_create(4);

// The loop itself must run off the main queue: dispatch_semaphore_wait blocks
// *the calling thread*, so driving this from the main thread freezes the UI
// as soon as 4 downloads are in flight.
dispatch_async(global, ^{
    for (NSURL *url in urls) {
        dispatch_semaphore_wait(limit, DISPATCH_TIME_FOREVER);
        dispatch_async(global, ^{
            [self downloadSynchronously:url];
            dispatch_semaphore_signal(limit);
        });
    }
});

+ (instancetype)sharedInstance {
    static MyManager *shared = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        shared = [[self alloc] init];
    });
    return shared;
}

@implementation ThreadSafeStore {
    NSMutableDictionary *_store;
    dispatch_queue_t _queue;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _store = [NSMutableDictionary dictionary];
        _queue = dispatch_queue_create("com.example.store", DISPATCH_QUEUE_CONCURRENT);
    }
    return self;
}

- (id)objectForKey:(NSString *)key {
    __block id value;
    dispatch_sync(_queue, ^{ value = self->_store[key]; });      // concurrent read
    return value;
}

- (void)setObject:(id)object forKey:(NSString *)key {
    dispatch_barrier_async(_queue, ^{ self->_store[key] = object; });   // exclusive write
}

@end