 <p>I've found a solution to my problem. Here again (in short) what I tried to accomplish.</p> <p>Task build an <code>NSMutableArray</code> which will act as the dataSource object for a <code>UITableView</code> each entry includes core data fetch and processing operations parallelise work and add results on completion, make sure access to the <code>NSMutableArray</code> is regulated start working with the dataSource object on completion</p> <p>Problems the number of entries in the dataSource object can vary</p> <p>Here's was worked for me. The category on 'NSMutableArray' is a convenience method to make sure the access is serialized. With that implementation you have parallelised the work as much as possible and you can savely write </p> <p>[self prepareDataSource]; [self.tableView reloadData];</p> <p>without worrying that some work is still in progress.</p> <pre class="lang-c prettyprint-override"><code>dispatch_queue_t queue = dispatch_queue_create("com.yourdomain.serializedAccess", DISPATCH_QUEUE_CONCURRENT); - (void)prepareDataSource { [self.dataSource removeAllObjects]; dispatch_group_t group = dispatch_group_create(); [self prepareWorkEntry1FromManagedObjectContext:self.privateContext forDataSource:self.dataSource group:group]; [self prepareWorkEntry2FromManagedObjectContext:self.privateContext forDataSource:self.dataSource group:group]; [self prepareWorkEntry3FromManagedObjectContext:self.privateContext forDataSource:self.dataSource group:group]; dispatch_group_wait(group, DISPATCH_TIME_FOREVER); } - (void)prepareWorkEntry1FromManagedObjectContext:(NSManagedObjectContext *)context forDataSource:(NSMutableArray *)array group:(dispatch_group_t)group { __weak typeof(self) weakSelf = self; dispatch_group_enter(group); [context performBlock:^{ Object *object = nil; createObject(object); if (object) { [array serializedAddObject:object withQueue:weakSelf.queue group:group]; } else { dispatch_group_leave(group); } }]; } @implementation NSMutableArray (ResourceProtection) - (void)serializedAddObject:(id)object withQueue:(dispatch_queue_t)queue group:(dispatch_group_t)group { if (group == NULL) { dispatch_barrier_async(queue, ^{ [self addObject:object]; }); } else { dispatch_barrier_async(queue, ^{ [self addObject:object]; dispatch_group_leave(group); }); } } @end </code></pre> <p>EDIT: As far as the ResourceProtection category is concerned you have to make sure</p> <ol> <li>dispatch_group_enter is called before dispatch_group_leave</li> <li>dispatch_group_enter and dispatch_group_leave are balanced</li> </ol> <p>Here it is an observed, synchronized writer scheme for a mutable object.</p>