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

我有一个表，它使用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
    }
}

//刷新用户表方法
类func refreshUserProfileTable（回调：（错误：NSError？->Void）{
//getProfile从服务器获取数据
ProfileWSFacade.getProfile（RequestManager.userID（）！）{
（配置文件，isLastPage，错误）->
DataBaseManager.sharedInstance.saveInBackground（{（backgroundContext））位于
让mediaList=配置文件？[“媒体”]作为阵列
如果let mediaList=mediaList{
//执行此循环时，响应时间延迟
对于mediaList中的媒体{
DataBaseManager.sharedInstance.storeObjectOfClass（Media.self，dict:Media，context:backgroundContext）
}
}
}，完成日期：{
回调（错误：error）
})
}
}
//标记：核心数据方法：
//数据库管理器中的“保存在后台”方法
func savenbackground(
block：（backgroundContext:NSManagedObjectContext）->Void，
完成：（作废->作废）？=无）
{
让mainThreadCompletion={
如果让完成=完成{
dispatch\u async（dispatch\u get\u main\u queue（），{（）->Void in
完成（）
})
}
}
backgroundContext.performBlock{（）->中的Void
guard RequestManager.userID（）！=nil else{
mainThreadCompletion（）
返回
}
块（backgroundContext:self.backgroundContext）
如果RequestManager.userID（）！=nil{
_=try？self.backgroundContext.save（）
DataBaseManager.sharedInstance.save（）
}
mainThreadCompletion（）
}
}
//存储类对象
类的func存储对象(
实体类：T.Type，
迪克特：杰森迪克迪亚，
上下文：NSManagedObjectContext？=nil）->T
{
let context=context？？mainManagedObjectContext
let predicate=NSPredicate（格式：“%K LIKE%@”、entityClass.primaryKey（）、entityClass.primaryKeyFromDict（dict））
让requestedObject=DataBaseManager.createOrUpdateFirstEntity(
entityType:T.self，
谓词：谓词，
上下文：中的上下文）{（实体）->（）
实体.populateFromDictionary（dict）
}
返回请求对象
}
//创建或更新核心数据实体
类func createOrUpdateFirstEntity(
entityType entityType:T.Type，
谓词：NSPredicate，
上下文：NSManagedObjectContext，
entityUpdateBlock:（实体：T）->（））->T
{
guard DataBaseManager.sharedInstance.doPersistentStoreAvailible（）else{return T（）}
让desc=NSEntityDescription.entityForName（字符串（entityType），inManagedObjectContext:context）！
让existingEntityRequest=NSFetchRequest（）
existingEntityRequest.entity=desc
existingEntityRequest.predicate=谓词
让requestedObject=try？context.executeFetchRequest（existingEntityRequest）。首先
如果让requestedObject=requestedObject为？T{
entityUpdateBlock（实体：requestedObject）
返回请求对象
}否则{
让newObject=T（实体：desc，insertIntoManagedObjectContext:context）
entityUpdateBlock（实体：newObject）
返回新对象
}
}

我发现

.performBlock

遵循先进先出规则。这意味着块将按其放入内部队列的顺序执行：。因此，下一个rest调用将等到第一个块完成后再保存，并进行回调。实际响应时间并不慢，这只是因为FIFO节省了时间

解决方案是使用不同的NSManagedContext加载配置文件，而不是使用用于所有后台调用的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()
    }
}

---

我发现

.performBlock

遵循先进先出的先进先出规则。这意味着块将按其放入内部队列的顺序执行：。因此，下一个rest调用将等到第一个块完成后再保存，并进行回调。实际响应时间并不慢，这只是因为FIFO节省了时间

解决方案是使用不同的NSManagedContext加载配置文件，而不是使用用于所有后台调用的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()
    }
}