Ответ 1

У меня есть несколько догадок в том порядке, в котором вы должны их проверить:

• Похоже, что все, что происходит медленно, происходит после сохранения данных (т.е. в обратном вызове). Это приводит меня к тому, что это перезагрузка PTSCollectionView или повторная выборка получаемого контроллера результатов.

• Возникает ли эта проблема с UICollectionView на iOS 6.x? Если нет, это приведет меня к PTSCollectionView.

• Если это все еще происходит, значит, это скорее не представление коллекции, а вместо получателя результатов. Как бы это выглядело, из фреймов стека (непрозрачных, хотя они могут быть), что выбранный контроллер результатов пытается выполнить выборку, которая происходит через dispatch_barrier. Они используются для обеспечения того, чтобы блок не выполнялся до тех пор, пока не будет достигнут барьер. Я здесь на конечности, но вы можете проверить это, потому что внутренне Core Data сохраняет в другом месте и, таким образом, задерживает выполнение любых других запросов на выборку. Опять же, такая дикая и необразованная догадка. Но я бы попробовал без исправления обновленного контроллера результатов сразу же и посмотрел, не произошло ли еще заикание.

Еще одна вещь, которая выделяется для меня: вы выполняете большую работу над дочерним MOC, но затем выполняете сохранение родителя. Похоже, что основная часть сохранения должна выполняться ребенком. Но также может быть, я не работал с этой частью Core Data через некоторое время: -)

Ответ 2

Я сделаю несколько предположений, но из вашего описания я считаю это разумным.

Во-первых, я предполагаю, что ваш основной MOC был создан с помощью

[[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];

Я делаю это предположение, потому что...

• Вы используете его как родительский контекст, поэтому он должен быть либо NSMainQueueConcurrencyType, либо NSPrivateQueueConcurrencyType.

• Поскольку вы используете его в другом месте, вы сделали бы это только в том случае, если бы он был доступен для доступа в основной очереди.

Теперь я также предполагаю, что вы связали основной MOC напрямую с координатором постоянного хранилища, а не с другим родительским MOC.

Когда фоновый MOC выполняет сохранение, его изменения распространяются в основной MOC (хотя они еще не сохранены). Поскольку ваш FRC подключен к основному MOC, он сразу увидит эти изменения.

Когда вы выдаете сохранение на основном MOC, ваш код будет заблокирован, потому что сохранение не вернется, пока сохранение не завершится.

Итак, то, что вы видите, полностью ожидается.

Есть много вариантов решения вашей проблемы.

Мое первое предложение состояло в том, чтобы создать MOC с частной очереди и сделать его родительским MOC главной очереди.

Это означает, что любое сохранение MOC главной очереди будет не. Вместо этого он "сохранит" данные родительскому элементу, который затем выполнит фактическое сохранение базы данных в собственной частной очереди и, как результат, в отдельном потоке в фоновом режиме.

Теперь это решит вашу проблему блокировки основного потока. Этот механизм также хорошо подходит для вашего дочернего MOC, загружающего базу данных.

Обратите внимание, что в iOS 5 есть несколько ошибок, связанных с вложенными контекстами, но если вы ориентируетесь на iOS 6, большинство из них были исправлены.

См. Основные данные не могут выполнить полную проверку для объекта после полученияPermanantIDs для получения дополнительной информации.

ИЗМЕНИТЬ

Ваши предположения верны, хотя я боюсь, что я нацелен на iOS 5 и может иметь только родительский MOC для основного MOC на iOS 6 (он вызывает тупик с FRC). - Пепельная ярость

Если вы видите тупик, сначала избавитесь от вызовов dispatch_sync и performBlockAndWait. Использование операции блокировки из основного потока никогда не должно происходить ни в чем, кроме самой простой синхронизации (т.е. Синхронизированной операции чтения из структуры данных)... и затем только при необходимости. Кроме того, вызовы синхронизации могут вызвать неожиданный тупик, поэтому его следует избегать, когда это возможно, особенно при вызове любого кода, который вы не контролируете напрямую.

Если вы не можете этого сделать, есть еще несколько вариантов. Тот, который мне больше всего нравится, - это присоединение FRC к приватной очереди-MOC, а затем "склеить" ваш доступ к FRC через главный поток. Вы можете dispatch_async в основной поток обрабатывать обновления делегата в виде таблицы (или что-то еще). Например...

- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller {
    dispatch_async(dispatch_get_main_queue(), ^{
        [tableView beginUpdates];
    });
}

Вы можете создать прокси для FRC, который является только интерфейсом, чтобы убедиться, что доступ соответствующим образом синхронизирован. Он не должен быть полным прокси-сервером... достаточно для того, что вы используете FRC для... и для обеспечения надлежащей синхронизации всех операций.

На самом деле это проще, чем кажется.

По сути, у вас будет такая же настройка, как у вас сейчас, за исключением того, что "main-MOC" будет MOC частной очереди вместо MOC главной очереди. Таким образом, ваш основной поток не будет блокироваться при доступе к базе данных.

Однако вам нужно принять несколько мер предосторожности, чтобы убедиться, что вы используете FRC в соответствующем контексте.

Другим вариантом является использование вашего основного MOC и FRC, как вы делаете сейчас, для обработки изменений в базе данных, но вносите все изменения в базу данных через отдельный MOC, прикрепленный непосредственно к координатору постоянного хранилища. Это приводит к изменениям в отдельном потоке. Затем вы используете уведомления о сохранении MOC для обновления вашего контекста и/или получения данных из хранилища.

Обновления iOS и OSX устраняют множество проблем с вложенными контекстами для Core Data, но есть некоторые вещи, о которых вам нужно беспокоиться при поддержке предыдущей версии.