Background thread method not solving freezing issue - ios

Question

I have my app freezing issue, So i used Instruments to find the issue and found that issues are related to CoreData save and fetch. I have tried background coredata method (parent-child, Notification) but my issue has been not resolved. Also I referred http://martiancraft.com/blog/2015/03/core-data-stack/ but dont know how this method implemeted in my app.
instrument log:
https://www.dropbox.com/s/agjtw1wqubsgwew/Instruments9.trace.zip?dl=0
SAVE to DB
-(void)updateThreadEntityWithSyncDetails:(NSMutableDictionary *)inDictionary
{
NSString *loginUser=[[NSUserDefaults standardUserDefaults] valueForKey:#"currentUser"];
AppDelegate *sharedDelegate = (AppDelegate *)[[UIApplication sharedApplication] delegate];
NSManagedObjectContext *context = [sharedDelegate managedObjectContext];
// NSManagedObjectContext *writerContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
// [writerContext setPersistentStoreCoordinator:[sharedDelegate persistentStoreCoordinator]];
// create main thread MOC
// context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
// context.parentContext = writerContext;
// NSManagedObjectContext *contextforThread = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
// contextforThread.parentContext = context;
// [contextforThread performBlock:^{
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
[fetchRequest setReturnsObjectsAsFaults:NO];
NSEntityDescription *entity = [NSEntityDescription entityForName:#"ThreadInfo"
inManagedObjectContext:context];
[fetchRequest setEntity:entity];
NSPredicate *userPredicate = [NSPredicate predicateWithFormat:#"userEmail == %#",loginUser];
NSPredicate *threadPredicate = [NSPredicate predicateWithFormat:#"threadID == %#",[inDictionary valueForKey:#"thread"]];
NSPredicate *compoundPredicate = [NSCompoundPredicate andPredicateWithSubpredicates: #[userPredicate, threadPredicate]];
[fetchRequest setPredicate:compoundPredicate];
NSArray *fetchedObjects = [context executeFetchRequest:fetchRequest error:nil];
for (ThreadInfo *threadInfo in fetchedObjects)
{
if([[inDictionary allKeys] containsObject:#"userEmail"])
{
if([inDictionary valueForKey:#"userEmail"]!=[NSNull null])
{
threadInfo.userEmail=[inDictionary valueForKey:#"userEmail"];
}
}
if([[inDictionary allKeys] containsObject:#"badgeValue"])
{
if([inDictionary valueForKey:#"badgeValue"]!=[NSNull null])
{
threadInfo.badgeValue=[inDictionary valueForKey:#"badgeValue"];
}
}
if([[inDictionary allKeys] containsObject:#"choice4Percentage"])
{
if([inDictionary valueForKey:#"choice4Percentage"]!=[NSNull null])
{
threadInfo.choice4Percentage=[inDictionary valueForKey:#"choice4Percentage"];
}
}
if([[inDictionary allKeys] containsObject:#"choice5Percentage"])
{
if([inDictionary valueForKey:#"choice5Percentage"]!=[NSNull null])
{
threadInfo.choice5Percentage=[inDictionary valueForKey:#"choice5Percentage"];
}
}
}
NSError *error;
if(![context save:&error]) {
NSLog(#"Child error : %#",error);
}
// [context performBlock:^{
// NSError *error;
// if(![context save:&error]) {
// NSLog(#"%#",error);
// }
// }];
// }];
}
FETCH
-(ThreadInfo *)retrieveSolicitationInfoForThreadID:(NSString*)inThreadID;
{
NSString *loginUser=[[NSUserDefaults standardUserDefaults] valueForKey:#"currentUser"];
AppDelegate *sharedDelegate = (AppDelegate *)[[UIApplication sharedApplication] delegate];
NSManagedObjectContext *context = [sharedDelegate managedObjectContext];
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
[fetchRequest setReturnsObjectsAsFaults:NO];
NSEntityDescription *entity = [NSEntityDescription entityForName:#"ThreadInfo"
inManagedObjectContext:context];
[fetchRequest setEntity:entity];
NSPredicate *userPredicate = [NSPredicate predicateWithFormat:#"userEmail == %#",loginUser];
NSPredicate *threadPredicate = [NSPredicate predicateWithFormat:#"threadID == %#",inThreadID];
\
NSPredicate *compoundPredicate = [NSCompoundPredicate andPredicateWithSubpredicates: #[userPredicate, threadPredicate]];
[fetchRequest setPredicate:compoundPredicate];
NSArray *fetchedObjects = [context executeFetchRequest:fetchRequest error:nil];
if(fetchedObjects.count!=0)
{
ThreadInfo *threadInfo=[fetchedObjects objectAtIndex:0];
return threadInfo;
}
return nil;
}
SYNC
-(void)updateSolicitationWithSyncDetails:(NSDictionary *)inDictionary
{
NSMutableDictionary *paramDict=[NSMutableDictionary dictionaryWithDictionary:inDictionary];
NSString *userEmail=[[NSUserDefaults standardUserDefaults] valueForKey:#"currentUser"];
[paramDict setObject:[NSNumber numberWithBool:NO] forKey:#"isSystemMessage"];
[paramDict setObject:userEmail forKey:#"userEmail"];
if([[inDictionary allKeys] containsObject:#"owned"])
{
BOOL isDuplicate=[[IXDataBaseManager sharedNetworkDataManager] checkForExistenceOfThreadDetailsForSolicitationID:[inDictionary objectForKey:#"solicitation"]];// FETCH
if(!isDuplicate)
{
int randomIndex=[[IXNetworkDataManager sharedNetworkDataManager] getIndexForColorImageForTab:#"OUT"];
[paramDict setObject:message forKey:#"threadDescription"];
[paramDict setObject:[NSNumber numberWithInt:randomIndex] forKey:#"colorCode"];
BOOL isDuplicateVal=[[IXDataBaseManager sharedNetworkDataManager] checkForExistenceOfSolicitationID:[inDictionary objectForKey:#"solicitation"]];// FETCH
[paramDict setObject:message forKey:#"threadDescription"];
ThreadInfo *threadInfo=[[IXDataBaseManager sharedNetworkDataManager] retrieveSolicitationInfoForThreadID:[inDictionary objectForKey:#"solicitation"]];
[paramDict setObject:threadInfo.threadID forKey:#"thread"];
[[IXDataBaseManager sharedNetworkDataManager] updateThreadEntityWithSyncDetails:paramDict];
}
}
}

Answer 1

First, thank you for making the code snippets and the trace available right away. That is very helpful.
So, looking at the trace and the code.
-updateThreadEntityWithSyncDetails: is being called on the main thread and is 33% of the time spent there. Not good.
You are passing nil for error: NEVER do that. Always pass an error pointer and check the results of your call to see if there is an error.
This conditional can be a lot cleaner:
if([[inDictionary allKeys] containsObject:#"userEmail"])
{
if([inDictionary valueForKey:#"userEmail"]!=[NSNull null])
{
threadInfo.userEmail=[inDictionary valueForKey:#"userEmail"];
}
}
Consider:
if (inDictionary[#"userEmail"] != nil && inDictionary[#"userEmail"] != [NSNull null]) {
threadInfo.userEmail = inDictionary[#"userEmail"];
}
Much easier to read.
This re-write of the method will get the work off the main thread:
- (void)updateThreadEntityWithSyncDetails:(NSMutableDictionary*)inDictionary
{
NSString *loginUser = [[NSUserDefaults standardUserDefaults] valueForKey:#"currentUser"];
AppDelegate *sharedDelegate = (AppDelegate *)[[UIApplication sharedApplication] delegate];
NSManagedObjectContext *context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
[context setParentContext:[sharedDelegate managedObjectContext]];
[context performBlock:^{
NSFetchRequest *fetchRequest = [NSFetchRequest fetchRequestWithEntityName:#"ThreadInfo"];
[fetchRequest setReturnsObjectsAsFaults:NO];
[fetchRequest setPredicate:[NSPredicate predicateWithFormat:#"userEmail == %# && threadID == %#",loginUser, inDictionary[#"thread"]];
NSArray *fetchedObjects = [context executeFetchRequest:fetchRequest error:nil];
for (ThreadInfo *threadInfo in fetchedObjects) {
if (inDictionary[#"userEmail"] != nil && inDictionary[#"userEmail"] != [NSNull null]) {
threadInfo.userEmail = inDictionary[#"userEmail"];
}
if (inDictionary[#"badgeValue"] != nil && inDictionary[#"badgeValue"] != [NSNull null]) {
threadInfo.badgeValue = inDictionary[#"badgeValue"];
}
if (inDictionary[#"choice4Percentage"] != nil && inDictionary[#"choice4Percentage"] != [NSNull null]) {
threadInfo.choice4Percentage = inDictionary[#"choice4Percentage"];
}
if (inDictionary[#"choice5Percentage"] != nil && inDictionary[#"choice5Percentage"] != [NSNull null]) {
threadInfo.choice5Percentage = inDictionary[#"choice5Percentage"];
}
}
NSError *error = nil;
if (![context save:&error]) {
NSLog(#"Child error : %#",error);
}
}];
}
BUT it may still block the main thread as I am guessing the bulk of the CPU time is in executing this fetch. The fetch is slow. You have TWO string compares in that fetch. That is bad and should be corrected. If the ThreadID is not a string then reverse the fetch. Otherwise this is just poor data model design and there isn't going to be much help other than fixing that fetch.
Your other really slow point is in -checkForExistenceOfThreadDetailsForThreadID:. You did not post that method but I suspect it is the same issue, your fetch is costing you a tremendous amount of time AND it is on the main queue.
Overall the design of this is poor and needs to be reworked. You are comparing strings in the data store which is one of the slowest ways to retrieve data. You are also on the main thread for things that do not appear to NEED to be on the main thread.
Remember the golden rule, if the data is NOT being manipulated BY the user then the manipulation MUST NOT be on the main queue. No exceptions.

Answer 2

Have you tried to use an separate Context for the operation and merge it with the mainContext after the the save?
E.g.
NSManagedObjectContext * localContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
[localContext setPersistentStoreCoordinator:[[self managedObjectContext] persistentStoreCoordinator]];
after your import is done you save your localContext
NSError * error = nil;
if (![[self localContext] save:&error]) {
NSLog(#"Unresolved error %#, %#", error, [error userInfo]);
}
This will write your data to the PersistentStore.
Now your mainContext needs to be informed about the changes in the PersistentStore. This is done by observing for a notification.
e.g.
[[NSNotificationCenter defaultCenter] addObserver:self
selector:#selector(didSaveNotification:)
name:NSManagedObjectContextDidSaveNotification
object:nil];
and this is the method which reacts to the notification:
- (void)didSaveNotification:(NSNotification *)notification
{
// NSLog(#"%s %#\n",__PRETTY_FUNCTION__,[notification userInfo]);
NSManagedObjectContext * mainContext = [self managedObjectContext];
void (^mergeChanges)(void)=^{
[mainContext mergeChangesFromContextDidSaveNotification:notification];
};
if([NSThread isMainThread]) {
mergeChanges();
} else {
dispatch_sync(dispatch_get_main_queue(), mergeChanges);
}
}
Using different NSManagedContext to work on the same PersistentStore is more threadsafe than working with a single NSManagedContext.

Answer 3

//Your Parent context init
- (NSManagedObjectContext *)managedObjectContext
{
if (_managedObjectContext != nil) {
return _managedObjectContext;
}
NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
if (coordinator != nil) {
_managedObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
[_managedObjectContext setPersistentStoreCoordinator:coordinator];
[_managedObjectContext setUndoManager:nil];
}
return _managedObjectContext;
}
- (NSManagedObjectContext *)childManagedObjectContext
{
if (_childManagedObjectContext != nil) {
return _childManagedObjectContext;
}
NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
if (coordinator != nil) {
_childManagedObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
[_childManagedObjectContext setPersistentStoreCoordinator:coordinator];
[_childManagedObjectContext setUndoManager:nil];
[[NSNotificationCenter defaultCenter] addObserver:self selector:#selector(_mocDidSaveNotification:) name:NSManagedObjectContextDidSaveNotification object:nil];
}
return _childManagedObjectContext;
}
- (void)_mocDidSaveNotification:(NSNotification *)notification
{
NSManagedObjectContext *savedContext = [notification object];
// ignore change notifications for the main MOC
if (_managedObjectContext == savedContext)
{
return;
}
if (_managedObjectContext.persistentStoreCoordinator != savedContext.persistentStoreCoordinator)
{
// that's another database
return;
}
dispatch_sync(dispatch_get_main_queue(), ^{
[_managedObjectContext mergeChangesFromContextDidSaveNotification:notification];
});
}
//Way to use the Parent- child context
[UIAppDelegate.childManagedObjectContext performBlock:^{
for (int i=0; i<count; i++) {
//Fill Database and save it in child context first for each entry and save it in child context
[UIAppDelegate.childManagedObjectContext save:nil];
}
dispatch_sync(dispatch_get_main_queue(), ^{
//Finally when u have inserted all entries save in the parent context
[UIAppDelegate.managedObjectContext save:nil];
});
}]
//Your code is huge to understand the logic but if you haven't tried in this way, just give it shot