ios - 在后台保存导致响应时间延迟(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 遵循 FIFO 规则，先进先出。这意味着 block 将按照它们放入内部队列的顺序执行:SO Link .因此，下一个 rest 调用将等到第一个 block 完成后再保存，并进行回调。实际响应时间并不慢，只是因为先进先出节省了时间。

解决方案是使用不同的 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()
    }
}