objective-c - 核心数据多线程导入（重复对象）

Question

我有一个 NSOperationQueue 将对象导入到我从 web api 获得的核心数据中。每个操作都有我应用的主 managedObjectContext 的私有子 managedObjectContext。每个操作都获取要导入的对象并检查该对象是否已经存在，在这种情况下它会更新现有对象。如果对象不存在，它会创建这个新对象。然后将私有子上下文上的这些更改传播到主托管对象上下文。

这个设置对我来说效果很好，但是有一个重复的问题。

当我在两个不同的并发操作中导入相同的对象时，我会得到具有完全相同数据的重复对象。（他们都检查对象是否存在，并且在他们看来它并不存在）。我将大约同时导入 2 个相同对象的原因是我经常处理“新”api 调用以及“get”api 调用。由于我的设置的并发异步性质，很难确保我永远不会尝试导入重复的对象。

所以我的问题是解决这个特定问题的最佳方法是什么？我考虑过将最大并发操作的导入限制为 1（由于性能，我不喜欢这个）。同样，我考虑在每次导入操作后都需要保存并尝试处理上下文的合并。此外，我考虑过在事后整理数据以偶尔清理重复项。最后，我考虑只处理所有获取请求的重复项。但是这些解决方案对我来说似乎都不是很好，也许我已经看过一个简单的解决方案。

score 5 · Accepted Answer

所以问题是：

上下文是一个暂存器——除非并且直到你保存，你在其中所做的更改不会被推送到持久存储；
您希望一个上下文知道对另一个尚未推送的更改。

对我来说，上下文之间的合并听起来并不可行——上下文不是线程安全的。因此，如果要发生合并，则其他上下文的线程/队列上不会进行任何其他操作。因此，您永远无法消除插入新对象而另一个上下文正在插入过程中途的风险。

其他意见：

SQLite 在任何实际意义上都不是线程安全的；
因此，无论您如何发布它们，所有到持久存储的旅行都会被序列化。

考虑到问题和 SQLite 限制，在我的应用程序中，我们采用了一个框架，其中网络调用自然是并发NSURLConnection的，结果的后续解析（JSON 解析加上一些钓鱼结果）同时发生，然后查找-or-create 步骤被引导到串行队列中。

序列化损失的处理时间非常少，因为无论如何 SQLite 行程都会被序列化，而且它们是序列化内容的绝大多数。

score 3 · Accepted Answer

首先在您的操作之间创建依赖关系。确保在其依赖项完成之前无法完成。

查看http://developer.apple.com/library/mac/documentation/Cocoa/Reference/NSOperation_class/Reference/Reference.html#//apple_ref/occ/instm/NSOperation/addDependency：

每个操作都应该在完成时调用 save 。接下来，我将尝试此处建议的 Find-Or-Create 方法：

https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/CoreData/Articles/cdImporting.html

它将解决您的重复问题，并且可能会导致您进行更少的提取（这既昂贵又缓慢，因此会很快耗尽电池电量）。

您还可以创建一个全局子上下文来处理所有导入，然后在最后合并整个巨大的东西，但这实际上归结为数据集的大小和您的内存考虑。

score 2 · Accepted Answer

我一直在为同样的问题苦苦挣扎一段时间。到目前为止关于这个问题的讨论给了我一些想法，我现在将分享这些想法。

请注意，这基本上是未经测试的，因为在我的情况下，我在测试期间很少看到这个重复的问题，而且我没有明显的方法可以轻松地重现它。

我有相同的 CoreData 堆栈设置 - 私有队列上的主 MOC，主队列上有一个子队列，它用作应用程序的主上下文。最后，批量导入操作（查找或创建）使用后台队列传递到第三个 MOC。操作完成后，保存将传播到 PSC。

我已经将我的所有核心数据堆栈从 AppDelegate 移到了一个单独的类 ( AppModel)，该类为应用程序提供了对域的聚合根对象() 的访问权限，Player并且还提供了一个用于在模型上执行后台操作的辅助函数 ( performBlock:onSuccess:onError:)。

对我来说幸运的是，所有主要的 CoreData 操作都是通过这种方法汇集起来的，所以如果我能确保这些操作是串行运行的，那么重复的问题就应该得到解决。

- (void) performBlock: (void(^)(Player *player, NSManagedObjectContext *managedObjectContext)) operation onSuccess: (void(^)()) successCallback onError:(void(^)(id error)) errorCallback
{
    //Add this operation to the NSOperationQueue to ensure that 
    //duplicate records are not created in a multi-threaded environment
    [self.operationQueue addOperationWithBlock:^{

        NSManagedObjectContext *managedObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
        [managedObjectContext setUndoManager:nil];
        [managedObjectContext setParentContext:self.mainManagedObjectContext];

        [managedObjectContext performBlockAndWait:^{

            //Retrive a copy of the Player object attached to the new context
            id player = [managedObjectContext objectWithID:[self.player objectID]];
            //Execute the block operation
            operation(player, managedObjectContext);

            NSError *error = nil;
            if (![managedObjectContext save:&error])
            {
                //Call the error handler
                dispatch_async(dispatch_get_main_queue(), ^{
                    NSLog(@"%@", error);
                    if(errorCallback) return errorCallback(error);
                });
                return;
            }

            //Save the parent MOC (mainManagedObjectContext) - WILL BLOCK MAIN THREAD BREIFLY
            [managedObjectContext.parentContext performBlockAndWait:^{
                NSError *error = nil;
                if (![managedObjectContext.parentContext save:&error])
                {
                    //Call the error handler
                    dispatch_async(dispatch_get_main_queue(), ^{
                        NSLog(@"%@", error);
                        if(errorCallback) return errorCallback(error);
                    });
                    return;
                }
            }];

            //Attempt to clear any retain cycles created during operation
            [managedObjectContext reset];

            //Call the success handler
            dispatch_async(dispatch_get_main_queue(), ^{
                if (successCallback) return successCallback();
            });
        }];
    }];
}

我在这里添加的希望能为我解决问题的内容是将整个内容包装在addOperationWithBlock. 我的操作队列简单配置如下：

single.operationQueue = [[NSOperationQueue alloc] init];
[single.operationQueue setMaxConcurrentOperationCount:1];

在我的 API 类中，我可能会按如下方式对我的操作执行导入：

- (void) importUpdates: (id) methodResult onSuccess: (void (^)()) successCallback onError: (void (^)(id error)) errorCallback
{
    [_model performBlock:^(Player *player, NSManagedObjectContext *managedObjectContext) {
        //Perform bulk import for data in methodResult using the provided managedObjectContext
    } onSuccess:^{
        //Call the success handler
        dispatch_async(dispatch_get_main_queue(), ^{
            if (successCallback) return successCallback();
        });
    } onError:errorCallback];
}

现在，随着NSOperationQueue时间的推移，应该不再可能同时进行多个批处理操作。

objective-c - 核心数据多线程导入（重复对象）

3 回答 3

Related

Reference