在后台保存会导致响应时间延迟（iOS）

Question

我有一个表，它使用 NSFetchedResultsController 来填充它的数据。当我刷新我的表时，我需要更新所有 50 多个项目，所以我执行以下操作：我调用返回 JSON 数据的服务器，将“媒体”对象存储到一个数组中，遍历这个数组并单独存储每个对象到核心数据（在后台线程中），然后重新加载表。这工作正常。但是有一个大问题。

有时，保存到数据库的步骤需要 7 秒以上，因为循环遍历大型数组并将每个对象单独存储到核心数据中。在执行此步骤时，当我从服务器获取其他数据时，响应时间会大大延迟。在保存过程完成之前，我将无法获取新数据。我很困惑，因为这应该在后台线程中完成，而不是阻止其他服务器调用。

为什么将数据保存到 bg 中的核心数据会导致我的响应时间延迟？有没有更好的方法在不中断任何响应的情况下将大型数组存储到核心数据？

//Refreshing User Table method
class func refreshUserProfileTable(callback: (error: NSError?) -> Void) {
    //getProfile fetches data from server
    ProfileWSFacade.getProfile(RequestManager.userID()!) {
        (profile, isLastPage, error) -> () in

        DataBaseManager.sharedInstance.saveInBackground({ (backgroundContext) in
            let mediaList = profile?["media"] as? Array<JSONDictionary>

            if let mediaList = mediaList {
                //Response time is delayed when this loop is executing
                for media in mediaList {
                    DataBaseManager.sharedInstance.storeObjectOfClass(Media.self, dict: media, context: backgroundContext)
                }
            }
            }, completion: {
                callback(error: error)
        })
    }
}

//MARK: Core data methods:
//Save in background method in Database manager
func saveInBackground(
    block: (backgroundContext: NSManagedObjectContext) -> Void,
    completion: (Void->Void)? = nil)
{
    let mainThreadCompletion = {
        if let completion = completion {
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                completion()
            })
        }
    }

    backgroundContext.performBlock { () -> Void in
        guard RequestManager.userID() != nil else {
            mainThreadCompletion()
            return
        }

        block(backgroundContext: self.backgroundContext)

        if RequestManager.userID() != nil {
            _ = try? self.backgroundContext.save()
            DataBaseManager.sharedInstance.save()
        }

        mainThreadCompletion()
    }
}

//Stores class object
func storeObjectOfClass<T: NSManagedObject where T: Mappable>(
    entityClass:T.Type,
    dict: JSONDictionary,
    context: NSManagedObjectContext? = nil) -> T
{
    let context = context ?? mainManagedObjectContext
    let predicate = NSPredicate(format: "%K LIKE %@", entityClass.primaryKey(), entityClass.primaryKeyFromDict(dict))
    let requestedObject = DataBaseManager.createOrUpdateFirstEntity(
        entityType: T.self,
        predicate: predicate,
        context: context) { (entity) -> () in
            entity.populateFromDictionary(dict)
    }

    return requestedObject
}

//Creates or updates core data entity
class func createOrUpdateFirstEntity<T: NSManagedObject>(
    entityType entityType: T.Type,
    predicate: NSPredicate,
    context: NSManagedObjectContext,
    entityUpdateBlock:(entity: T) -> ()) -> T
{
    guard DataBaseManager.sharedInstance.doPersistentStoreAvailible() else { return T() }

    let desc = NSEntityDescription.entityForName(String(entityType), inManagedObjectContext: context)!
    let existingEntityRequest = NSFetchRequest()
    existingEntityRequest.entity = desc
    existingEntityRequest.predicate = predicate
    let requestedObject = try? context.executeFetchRequest(existingEntityRequest).first

    if let requestedObject = requestedObject as? T {
        entityUpdateBlock(entity: requestedObject)
        return requestedObject
    } else {
        let newObject = T(entity: desc, insertIntoManagedObjectContext: context)
        entityUpdateBlock(entity: newObject)
        return newObject
    }
}

Answer 1

我发现.performBlock 遵循先进先出的规则。这意味着这些块将按照它们被放入内部队列的顺序执行：SO Link。因此，下一个 rest 调用将等到第一个块完成后才保存，并进行回调。实际响应时间并不慢，只是因为先进先出，节省了时间。

解决方案是使用不同的 NSManagedContext 来加载配置文件，而不是使用用于所有后台调用的那个。

let profileContext: NSManagedObjectContext

//Instead of calling saveInBackground, we save to saveInProfileContext, which wont block other rest calls.
func saveInProfileContext(
    block: (profileContext: NSManagedObjectContext) -> Void,
    completion: (Void->Void)? = nil)
{

    let mainThreadCompletion = {
        if let completion = completion {
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                completion()
            })
        }
    }

    profileContext.performBlock { () -> Void in
        guard RequestManager.userID() != nil else {
            mainThreadCompletion()
            return
        }

        block(profileContext: self.profileContext)
        if RequestManager.userID() != nil {
            _ = try? self.profileContext.save()
            DataBaseManager.sharedInstance.save()
        }
        mainThreadCompletion()
    }
}