Grand Central Dispatch (GCD) with CoreData

15,156

Solution 1

As you probably know or have noticed you must perform UI operations on the main thread. As you mention it is when you save the UI update takes place. You can solve this by nesting a call to dispatch_sync on the main thread.

dispatch_queue_t main_queue = dispatch_get_main_queue();
dispatch_queue_t request_queue = dispatch_queue_create("com.app.request", NULL);

__block __typeof__(self) blockSelf = self;

dispatch_async(request_queue, ^{
    MyNSManagedObject *mObject = [blockSelf.fetchedResultsController objectAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];

    // update and heavy lifting...

    dispatch_sync(main_queue, ^{
      [blockSelf saveManagedObjectContext];
    });
});     

The use of blockSelf is to avoid creating accidentally reference cycles. (Practical blocks)

Solution 2

There is a golden rule when it comes to Core Data - one Managed Object Context per thread. Managed object contexts are not thread safe so if you are doing work in a background task you either use the main thread to avoid threading conflicts with UI operations, or you create a new context to do the work in. If the work is going to take a few seconds then you should do the latter to stop your UI from locking up.

To do this you create a new context and give it the same persistent store as your main context:

NSManagedObjectContext *backgroundContext = [[[NSManagedObjectContext alloc] init] autorelease];
[backgroundContext setPersistentStoreCoordinator:[mainContext persistentStoreCoordinator]];

Do whatever operations you need to do, then when you save that new context you need to handle the save notification and merge the changes into your main context with the mergeChangesFromContextDidSaveNotification: message. The code should look something like this:

/* Save notification handler for the background context */
- (void)backgroundContextDidSave:(NSNotification *)notification {
    /* Make sure we're on the main thread when updating the main context */
    if (![NSThread isMainThread]) {
        [self performSelectorOnMainThread:@selector(backgroundContextDidSave:)
                               withObject:notification
                            waitUntilDone:NO];
        return;
    }

    /* merge in the changes to the main context */
    [self.managedObjectContext mergeChangesFromContextDidSaveNotification:notification];
}

/* ... */

/* Save the background context and handle the save notification */
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(backgroundContextDidSave:)
                                             name:NSManagedObjectContextDidSaveNotification
                                           object:backgroundContext];

[backgroundContext save:NULL];

[[NSNotificationCenter defaultCenter] removeObserver:self
                                                name:NSManagedObjectContextDidSaveNotification
                                              object:syncContext];

Handling the save notifcation and merging is important otherwise your main UI/context won't see the changes you made. By merging, your main fetchResultsController etc. will get change events and update your UI as you would expect.

Another important thing to note is that NSManagedObject instances can only be used in the context that they were fetched from. If your operation needs a reference to an object then you have to pass the object's objectID to the operation and re-fetch an NSManagedObject instance from the new context using existingObjectWithID:. So something like:

/* This can only be used in operations on the main context */
MyNSManagedObject *objectInMainContext =
    [self.fetchedResultsController objectAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];

/* This can now be used in your background context */
MyNSManagedObject *objectInBackgroundContext =
    (MyNSManagedObject *) [backgroundContext existingObjectWithID:[objectInMainContext objectID]];
Share:
15,156

Related videos on Youtube

Mustafa
Author by

Mustafa

I'm a Manager Development/Project Manager/Team Lead/Mobile Application Developer located in Islamabad, Pakistan, working for BroadPeak Technologies. I'm currently focusing on managing and developing mobile applications for Android and iOS devices; with hands on experience developing iOS applications. More information.

Updated on August 21, 2020

Comments

  • Mustafa
    Mustafa over 3 years

    I'm using Grand Central Dispatch (GCD) in my application to do some heavy lifting. The application is using Core-Data for data storage purposes. Here's my scenario (along with relevant question):

    dispatch_queue_t main_queue = dispatch_get_main_queue();
    dispatch_queue_t request_queue = dispatch_queue_create("com.app.request", NULL);
    
    dispatch_async(request_queue, ^{
        MyNSManagedObject *mObject = [self.fetchedResultsController objectAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
    
        // … 
        // <heavy lifting>
        // … 
    
        // … 
        // <update mObject>
        // … 
    
        [self saveManagedObjectContext];
    });     
    

    As a result of [self saveManagedObjectContext], fetchResultsController delegate methods are called automatically. Consequently, the UI updation logic kicks.

    Now my question is, do I need to use main_queue for -saveManagedObjectContext? Should I perform all operations on my NSManagedObject in main_queue? Some of the operations that update the NSManagedObject might take 2-3 seconds. Please advise.

  • Mustafa
    Mustafa over 13 years
    So, what your saying is that in my case, instead of using fetchedResultsController, i should create a new managed object context (backgroundManagedObjectContext), fetch the required managed object, perform required operations, update the managed object, save this managed object context (backgroundManagedObjectContext), and then merge changes to reflect in the main managed object context? This will make my life pretty darn miserable.
  • Mike Weller
    Mike Weller over 13 years
    You can still use fetched results controller to display and update stuff in your UI. The code I have shown you is all that is required to perform whatever operations you need in a separate context, nothing else should change.
  • aroth
    aroth almost 12 years
    There are ways around this golden rule: github.com/adam-roth/coredata-threadsafe.
  • Todd
    Todd over 11 years
    With the line -removeObserver: did you mean 'backgroundContext' instead of 'syncContext' for the object: parameter? My apologies if that's a daft question, I'm really struggling with threaded core data manipulation!
  • Victor Engel
    Victor Engel over 10 years
    @aroth, on your github repository you state, "Update every class that you have that derives from NSManagedObject so that it derives from IAThreadSafeManagedObject instead. To accomplish this, do: #import <IAThreadSafeCoreData/IAThreadSafeManagedObject.h> (at)interface MyManagedObjectSubclass : IAThreadSafeManagedObject" Does this mean the Xcode-generated classes must be modified?
  • Victor Engel
    Victor Engel over 10 years
    @aroth, I think I've run into a problem. How can I contact you to troubleshoot? I'm getting a crash at IAThreadSafeManagedObject.m line 73 [self setPrimitiveValue:obj forKey:propertyName]; after several thousand successful transactions.
  • Victor Engel
    Victor Engel over 10 years
    @aroth, never mind. I've opted for an alternative. But, in case you wish to pursue this, the problem came when I added dozens of views as subviews to a new view, then quickly moved them to a different view and deleted the one they originally were made subviews of. The problem occurred because threads adding the relationship were still taking place after the view had been deleted, so it was trying to set up a relationship with a nonexistent object. Using the isDeleted method did not prevent this problem.