objective-c - 核心数据批量插入突然减慢到速度的 1/10

Question

我正在批量插入核心数据。我有一个人对象，这个人对象有一个名为“otherPeople”的关系，它是人的 NSSet。当从下载中批量插入数据时，一切都很好，直到大约 10,000 人被读入，此时批量插入速度减慢到爬行。我每插入 500 次就保存并重置我的 NSManagedObjectContext。

如果我注释掉插入“otherPerson”关系的部分，批量插入在整个下载过程中会很快。 parseJSON 在 500 个 JSONKit 词典中被批量调用。

知道是什么原因造成的吗？可能的解决方案？

代码:

- (NSArray*) getPeople:(NSArray*)ids
{
    NSFetchRequest* request = [[[NSFetchRequest alloc] init] autorelease];
    NSEntityDescription* entityDescription = [NSEntityDescription entityForName:@"Person" inManagedObjectContext:context];
    [request setEntity:entityDescription];
    [request setFetchBatchSize:ids.count];

    //Filter by array of ids
    NSPredicate* predicate = [NSPredicate predicateWithFormat:@"externalId IN %@", ids];
    [request setPredicate:predicate];

    NSError* _error;
    NSArray* people = [context executeFetchRequest:request error:&_error];

    return people;
}

- (void) parseJSON:(NSArray*)people
{
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
    NSMutableArray* idsToFetch = [NSMutableSet setWithCapacity:CHUNK_SIZE * 3];
    NSMutableDictionary* existingPeople = [NSMutableDictionary dictionaryWithCapacity:CHUNK_SIZE * 3];

    // populate the existing people dictionary first, that way we know who is already in the context without having to do a fetch for each person in the array (externalId IS indexed)
    for (NSDictionary* personDictionary in people)
    {
        // uses JSON kit to parse out all the external ids...
        [PersonJSON addExternalIdsToArray:idsToFetch fromDictionary:personDictionary];
    }

    // see above code for getPeople implementation...
    NSArray* existingPeopleArray = [self getPeople:idsToFetch];
    for (Person* p in existingPeopleArray)
    {
        [existingPeople setObject:p forKey:p.externalId];
    }

    for (NSDictionary* personDictionary in people)
    {
        NSString* externalId = [personDictionary objectForKey:@"PersonId"];
        Person* person = [existingPeople objectForKey:externalId];

        if (person == nil)
        {
            // the person was not in the context, make a new person in the context
            person = [[self newPerson] autorelease];
            person.ancestryId = externalId;
            [existingPeople setObject:person forKey:person.externalId];
        }

        // use JSON kit to populate the core data object...
        [PersonJSON populatePerson:person withDictionary:personDictionary inContext:[self context]];

        // these are just objects that contain an externalId, showing that the link hasn't been setup yet
        for (UnresolvedOtherPerson* other in person.unresolvedOtherPeople)
        {
            Person* relatedPerson = [existingPeople objectForKey:other.externalId];

            if (relatedPerson == nil)
            {
                relatedPerson = [[self newPerson] autorelease];
                relatedPerson.externalId = other.externalId;
                [existingPeople setObject:relatedPerson forKey:relatedPerson.externalId];
            }

            // add link - if I comment out this line, everything runs very fast
            // if I don't comment out, things slow down gradually and then exponentially
            [person addOtherPersonsObject:relatedPerson];
        }

        self.downloaded++;
    }

    [pool drain];
}

Answer 1

将对象添加到关系会导致双方的关系都被触发。因此，如果您有 A <<->> B 并说您正在尝试将新创建的 A 对象添加到已经与 100,000 个 A 对象相关联的 B 对象，则 CoreData 将从存储中获取这 100,000 个对象以实现之前的关系添加新关系。

事实上，您每隔一段时间就清除 mangedobjectcontext，这意味着为满足关系而加载的所有 100,000 个对象 CD 现在需要重新加载，从而使过程极其缓慢。

解决此问题的一种方法是执行两步导入过程。首先在不建立任何关系的情况下将所有对象加载到 db 中，但要跟踪需要添加的关系。一旦你像这样快速导入，然后回到数据库并添加关系和清晰的上下文，以避免核心数据必须过于频繁地重新加载关系。所以作为一个具体的例子，如果你需要导入 100 万个 A，需要关联 100 个 B，首先导入所有的 As，然后对于一百个 B 中的每一个，加载关系一次并将所有 A 添加到其中，清除上下文，继续下一个 B，依此类推。这里的关键是防止上下文重置它刚刚痛苦地加载的那些 100k 记录。

另一种解决方法是不定期重置整个上下文，而是只刷新您想要删除的对象。

哦，还有一件事，你也可以考虑在 CoreData 中建立单向关系，并使用显式获取来获取关系的另一端

编辑:

我想我找到了解决方法。您需要调用原始访问器。所以像

        [self.primitiveTags addObject:tag];

初步测试似乎表明，这不会迫使关系的另一方开火